(cfr_thres_infrac)\\n cfr = 100*scaled_bias[cfr].shape[0]/scaled_bias.shape[0]\\n return scaled_bias, nmad, std, cfr\",\n \"def relatedness(self):\\n if self.het_1 * self.het_2:\\n return (self.het_1_2 - 2 * self.n_ibs0) * 2 / math.sqrt(self.het_1 * self.het_2)\\n else:\\n return 0.0\",\n \"def get_iPTF16hgs(colorplt = False):\\n z = 0.017\\n ebv = 0\\n D = cosmo.luminosity_distance([z])[0].value * 1e+6 # in pc\\n dis_mod = 5*np.log10(D / 10)\\n \\n tb = pd.read_csv('../data/otherSN/iPTF16hgs/table1.txt', sep=\\\"\\\\t\\\")\\n tb = tb.drop(columns=[\\\"Unnamed: 5\\\"])\\n tb = tb.rename(columns={'Filter' : 'filter',\\n 'MJD': 'mjd'})\\n tb = tb[~np.array([x[0]=='>' for x in tb['Magnitude'].values])]\\n tb['mag'] = np.array([float(x.split(\\\" +or-\\\")[0]) for x in tb['Magnitude'].values])\\n tb['emag'] = np.array([float(x.split(\\\" +or-\\\")[1]) for x in tb['Magnitude'].values])\\n tb = tb.drop(columns=[\\\"Magnitude\\\"])\\n \\n ixg = tb['filter'].values == \\\"g\\\"\\n ixr = tb['filter'].values == \\\"r\\\"\\n ixi = tb['filter'].values == \\\"i\\\"\\n tb['wave'] = np.zeros(len(tb))\\n tb['wave'].values[ixg] = 4814\\n tb['wave'].values[ixr] = 6422\\n tb['wave'].values[ixi] = 7883\\n tb['mag0'] = tb['mag'] - extinction.ccm89(tb['wave'].values, 3.1*ebv, 3.1)\\n tb['mag0_abs'] = tb['mag0'] - dis_mod\\n t_max = 57691.59 # from the paper\\n tb['tmax_of'] = tb['mjd'] - t_max\\n tb['tmax_rf'] = (tb['mjd'] - t_max) / (1+z)\\n \\\"\\\"\\\"\\n plt.errorbar(tb[\\\"tmax_rf\\\"].values[ixg], tb[\\\"mag\\\"].values[ixg], tb[\\\"emag\\\"].values[ixg], fmt=\\\".g\\\")\\n plt.errorbar(tb[\\\"tmax_rf\\\"].values[ixr], tb[\\\"mag\\\"].values[ixr], tb[\\\"emag\\\"].values[ixr], fmt=\\\".r\\\")\\n plt.errorbar(tb[\\\"tmax_rf\\\"].values[ixi], tb[\\\"mag\\\"].values[ixi], tb[\\\"emag\\\"].values[ixi], fmt=\\\".y\\\")\\n \\\"\\\"\\\"\\n tb = add_datecol(tb)\\n tb = add_physcol(tb)\\n #tb = tb.drop(columns=[\\\"datetime64\\\"])\\n if colorplt==False:\\n return tb\\n else:\\n #tb = tb[tb.mjd > 55352.5]\\n #tb = tb[tb.mjd < 55593.5]\\n \\n dates = get_date_span(tb)\\n datesave = []\\n for i in range(len(dates)):\\n x = dates[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n if len(tbsub)!=0:\\n flts = tbsub['filter'].values\\n if \\\"r\\\" in flts and np.sum(np.unique(flts))!=1:\\n datesave.append(x)\\n datesave = np.array(datesave)\\n \\n mcolor = []\\n mcolor_unc = []\\n mjds = []\\n colorname = []\\n for i in range(len(datesave)):\\n x = datesave[i]\\n ix = tb[\\\"date\\\"].values == x\\n tbsub = tb[ix]\\n gtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"g\\\"]\\n rtb = tbsub[tbsub[\\\"filter\\\"].values==\\\"r\\\"]\\n itb = tbsub[tbsub[\\\"filter\\\"].values==\\\"i\\\"]\\n if len(gtb)!=0:\\n gmjds = gtb[\\\"mjd\\\"].values\\n gmags = gtb[\\\"mag0\\\"].values\\n gemags = gtb[\\\"emag\\\"].values\\n gwtgs = 1/gemags**2\\n gmag = np.sum(gmags * gwtgs) / np.sum(gwtgs)\\n gmjd = np.sum(gmjds * gwtgs) / np.sum(gwtgs)\\n gemag = 1/ np.sqrt(np.sum(gwtgs))\\n if len(rtb)!=0:\\n rmjds = rtb[\\\"mjd\\\"].values\\n rmags = rtb[\\\"mag0\\\"].values\\n remags = rtb[\\\"emag\\\"].values\\n rwtgs = 1/remags**2\\n rmag = np.sum(rmags * rwtgs) / np.sum(rwtgs)\\n rmjd = np.sum(rmjds * rwtgs) / np.sum(rwtgs)\\n remag = 1/ np.sqrt(np.sum(rwtgs))\\n if len(itb)!=0:\\n imjds = itb[\\\"mjd\\\"].values\\n imags = itb[\\\"mag0\\\"].values\\n iemags = itb[\\\"emag\\\"].values\\n iwtgs = 1/iemags**2\\n imag = np.sum(imags * iwtgs) / np.sum(iwtgs)\\n imjd = np.sum(imjds * iwtgs) / np.sum(iwtgs)\\n iemag = 1/ np.sqrt(np.sum(iwtgs))\\n if len(gtb)!=0 and len(rtb)!=0:\\n mcolor.append(gmag - rmag)\\n mjds.append( 0.5 * (gmjd + rmjd) )\\n mcolor_unc.append( np.sqrt(gemag**2 + remag**2) )\\n colorname.append(\\\"gmr\\\")\\n if len(rtb)!=0 and len(itb)!=0:\\n mcolor.append(rmag - imag)\\n mjds.append( 0.5 * (rmjd + imjd) )\\n mcolor_unc.append( np.sqrt(remag**2 + iemag**2) )\\n colorname.append(\\\"rmi\\\")\\n \\n ctb = Table(data = [mjds, mcolor, mcolor_unc, colorname],\\n names = [\\\"mjd\\\", \\\"c\\\", \\\"ec\\\", \\\"cname\\\"])\\n \\n ctb['tmax_rf'] = (ctb['mjd'] - t_max) / (1+z)\\n ctb = ctb.to_pandas()\\n return ctb\",\n \"def plot_field_uncertainties():\\n\\n resize_size = (1000, 1000)\\n\\n\\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\\n if drug_name == 'DMSO':\\n dirs = [os.path.join(path_to_here, '../data/landscape_visualizations/{}/{}/30_hours/'.format(drug_name, j)) for j in ['original', 'repeat_a', 'repeat_b']]\\n\\n def transform(x):\\n if type(x) is np.ndarray:\\n x = change_array_lims(x)\\n x = np.log(x)\\n return x\\n\\n F_unc_vmin = -7\\n F_unc_vmax = -4\\n sigma_vmin = -5\\n sigma_vmax = 0 #0.4\\n sigma_unc_vmin = -6\\n sigma_unc_vmax = -2\\n\\n fig_Fs = [plt.figure() for _ in range(3)]\\n fig_uncertainty = plt.figure()\\n sigma_lists, F_arrays = [], []\\n for idx_fig, dir in enumerate(dirs):\\n\\n p_list = _load_and_resize_list(dir+'p_list_0.pickle')\\n D_list = _load_and_resize_list(dir+'D_list_0.pickle')\\n U_array = pickle.load(open(dir+'U.pickle', 'rb'))\\n U_array = cv2.resize(U_array, resize_size, interpolation = cv2.INTER_LINEAR)\\n Gx, Gy = np.gradient(U_array, 26./resize_size[0], 26./resize_size[0]) # gradients with respect to x and y\\n F_array = (Gx**2+Gy**2)**.5 # gradient magnitude\\n F_array[np.isinf(F_array)] = np.nan\\n F_array[p_list[-1]<1e-3]=np.nan # final PDF\\n sigma_list = []\\n for j in range(9):\\n arr = D_list[2*j] # current PDF\\n arr[p_list[j]<1e-3]=np.nan\\n sigma_list.append(np.sqrt(2*arr))\\n\\n\\n sigma_lists.append(sigma_list)\\n F_arrays.append(F_array)\\n\\n ax = fig_Fs[idx_fig].add_subplot(111)\\n ax.imshow(transform(F_array)[::-1, :], cmap = cmap, vmin = -4.6, vmax = -2)\\n ax.set_title(dir)\\n\\n all_axes = [i for j in fig_Fs for i in j.axes]\\n for ax in all_axes:\\n ax.axis('off')\\n\\n # uncertainties\\n\\n std = np.std(F_arrays, axis = 0)\\n ax = fig_uncertainty.add_subplot(121)\\n ax.imshow(transform(std)[::-1, :], cmap = cmap, vmin = F_unc_vmin, vmax = F_unc_vmax)\\n ax.set_title('F_uncertainty')\\n\\n fig_sigma = plt.figure()\\n ax = fig_sigma.add_subplot(111)\\n ax.imshow(transform(np.nanmean(sigma_lists[0], axis = 0))[::-1, :], cmap = cmap, vmin = sigma_vmin, vmax = sigma_vmax) # index 0 (i.3 'original' is corresponds to the landscapes in other figures)\\n ax.set_title('sigma_mean')\\n\\n sigma_means = [np.nanmean(sigma_list, axis = 0) for sigma_list in sigma_lists]\\n std_array = np.nanstd(sigma_means, axis = 0)\\n ax = fig_uncertainty.add_subplot(122)\\n ax.imshow(transform(std_array)[::-1, :], cmap = cmap, vmin = sigma_unc_vmin, vmax = sigma_unc_vmax)\\n ax.set_title('sigma_uncertainty')\\n\\n fig_sigma.savefig(path_to_here+'/../outputs/{}_mean_sigma.png'.format(drug_name), dpi = 1200)\\n fig_uncertainty.savefig(path_to_here+'/../outputs/{}_uncertainties.png'.format(drug_name), dpi = 1200)\",\n \"def h8_rmshe(simulated_array, observed_array, replace_nan=None, replace_inf=None, remove_neg=False,\\n remove_zero=False):\\n\\n # Treats data\\n simulated_array, observed_array = treat_values(\\n simulated_array,\\n observed_array,\\n replace_nan=replace_nan,\\n replace_inf=replace_inf,\\n remove_neg=remove_neg,\\n remove_zero=remove_zero\\n )\\n\\n h = (simulated_array / observed_array - 1) / np.max(simulated_array / observed_array)\\n return np.sqrt(np.mean(h ** 2))\",\n \"def _compute_noise_level(self, data):\\n noise = max(data)\\n noise_min = 2600\\n noise_max = 4095\\n ratio = (noise - noise_min)/(noise_max - noise_min)\\n return int(ratio*100)\",\n \"def chrx_het_hom_ratio(self, sample):\\n try:\\n variant_set = self.latest_variant_set\\n if not variant_set:\\n return -1\\n else:\\n sample_stats = variant_set.variant_stats.sample_variant_stats.get(\\n sample_name=sample\\n )\\n return sample_stats.chrx_het_hom\\n except SmallVariantSet.variant_stats.RelatedObjectDoesNotExist:\\n return -1.0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62044317","0.59503055","0.5934977","0.58116406","0.5744772","0.5688612","0.5682206","0.5657256","0.5637151","0.56292534","0.562283","0.56201357","0.5602905","0.5597058","0.55753255","0.55715555","0.55521727","0.5543683","0.55348676","0.5511092","0.55000806","0.5490362","0.54900813","0.54887897","0.5488657","0.54636854","0.5455198","0.5453186","0.54511994","0.54284585","0.5423433","0.54104555","0.5409513","0.54072773","0.53973216","0.53954595","0.5379178","0.53791606","0.5363158","0.5352548","0.5352418","0.53492045","0.53463465","0.53406274","0.5338696","0.53322953","0.5315361","0.5312856","0.5312338","0.53018606","0.5301406","0.5300627","0.5294929","0.5289337","0.52842194","0.5276285","0.52701527","0.5269589","0.5261867","0.5260391","0.5259202","0.5257481","0.52569985","0.52548367","0.5254307","0.525423","0.5253085","0.52508456","0.5242489","0.52407867","0.5233287","0.5231196","0.52272666","0.5226622","0.5225305","0.52221376","0.5222065","0.52149194","0.52119106","0.5208134","0.520745","0.52062744","0.520388","0.5189314","0.5189196","0.5186154","0.5176306","0.5175754","0.51745254","0.5171152","0.516614","0.5165275","0.51617527","0.5155121","0.5154516","0.514691","0.51465046","0.514444","0.51419127","0.5139073"],"string":"[\n \"0.62044317\",\n \"0.59503055\",\n \"0.5934977\",\n \"0.58116406\",\n \"0.5744772\",\n \"0.5688612\",\n \"0.5682206\",\n \"0.5657256\",\n \"0.5637151\",\n \"0.56292534\",\n \"0.562283\",\n \"0.56201357\",\n \"0.5602905\",\n \"0.5597058\",\n \"0.55753255\",\n \"0.55715555\",\n \"0.55521727\",\n \"0.5543683\",\n \"0.55348676\",\n \"0.5511092\",\n \"0.55000806\",\n \"0.5490362\",\n \"0.54900813\",\n \"0.54887897\",\n \"0.5488657\",\n \"0.54636854\",\n \"0.5455198\",\n \"0.5453186\",\n \"0.54511994\",\n \"0.54284585\",\n \"0.5423433\",\n \"0.54104555\",\n \"0.5409513\",\n \"0.54072773\",\n \"0.53973216\",\n \"0.53954595\",\n \"0.5379178\",\n \"0.53791606\",\n \"0.5363158\",\n \"0.5352548\",\n \"0.5352418\",\n \"0.53492045\",\n \"0.53463465\",\n \"0.53406274\",\n \"0.5338696\",\n \"0.53322953\",\n \"0.5315361\",\n \"0.5312856\",\n \"0.5312338\",\n \"0.53018606\",\n \"0.5301406\",\n \"0.5300627\",\n \"0.5294929\",\n \"0.5289337\",\n \"0.52842194\",\n \"0.5276285\",\n \"0.52701527\",\n \"0.5269589\",\n \"0.5261867\",\n \"0.5260391\",\n \"0.5259202\",\n \"0.5257481\",\n \"0.52569985\",\n \"0.52548367\",\n \"0.5254307\",\n \"0.525423\",\n \"0.5253085\",\n \"0.52508456\",\n \"0.5242489\",\n \"0.52407867\",\n \"0.5233287\",\n \"0.5231196\",\n \"0.52272666\",\n \"0.5226622\",\n \"0.5225305\",\n \"0.52221376\",\n \"0.5222065\",\n \"0.52149194\",\n \"0.52119106\",\n \"0.5208134\",\n \"0.520745\",\n \"0.52062744\",\n \"0.520388\",\n \"0.5189314\",\n \"0.5189196\",\n \"0.5186154\",\n \"0.5176306\",\n \"0.5175754\",\n \"0.51745254\",\n \"0.5171152\",\n \"0.516614\",\n \"0.5165275\",\n \"0.51617527\",\n \"0.5155121\",\n \"0.5154516\",\n \"0.514691\",\n \"0.51465046\",\n \"0.514444\",\n \"0.51419127\",\n \"0.5139073\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6009351"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":23195,"cells":{"query":{"kind":"string","value":"This function is where any userspecified values shoulbe be. Given shots in the x, y and z direction, it finds position vectors (a 16 by 3 array becuase there are 16 probe locations (4 locations on 4 probes) and each probe location has an x, y, and z coordinate relative to the center of the Bfield) then uses those positions to calculate the magnetic field at that point. Then,"},"document":{"kind":"string","value":"def generateMatrix():\n num_probes = 16\n\n # print(position_vectors)\n # Create the (48x4) calibration matrix:\n calibration_lookup= [[0] * 3 for i in range(num_probes)]\n calibration_matrix = [[0] * 9 for i in range(num_probes)]\n counter = 0\n\n # first populate with x-direction:\n shot_range = [17, 20] #x-direction\n dir = 0 #the direction of the orentation of the probe array\n position_vectors = get_probeLocs_calib_setup(dir)\n for probe_num in range(num_probes):\n position_vector = position_vectors[probe_num]\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\n calibration_lookup[probe_num][dir] = ratio_Bx\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\n print(\"Progress: %d / %d\" %(counter+1,num_probes*3 ))\n counter +=1\n\n # Then populate with y-direction:\n shot_range = [21, 25] #y-direction\n dir = 1 #the direction of the orentation of the probe array\n position_vectors = get_probeLocs_calib_setup(dir)\n for probe_num in range(num_probes):\n position_vector = position_vectors[probe_num]\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\n calibration_lookup[probe_num][dir] = ratio_By\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\n print(\"Progress: %d / %d\" %(counter+1,num_probes*3 ))\n counter +=1\n\n # Then populate with z-direction:\n shot_range = [11, 15] #z-direction\n dir = 2\n position_vectors = get_probeLocs_calib_setup(dir)\n for probe_num in range(num_probes):\n position_vector = position_vectors[probe_num]\n ratio_Bx, ratio_By, ratio_Bz, norm_factor= getRatio(probe_num, position_vector, shot_range, dir)\n calibration_lookup[probe_num][dir] = ratio_Bz\n calibration_matrix[probe_num][(dir*3):(dir*3+1)] = [ratio_Bx, ratio_By, ratio_Bz]\n print(\"Progress: %d / %d\" %(counter+1,num_probes*3 ))\n counter +=1\n\n pth = os.getcwd()\n date = '050119'\n print(\"Finished! File saved as calib-%s-4x4_lookup.txt and _3x3 in current working directory\" %(date))\n savetxt(os.path.join(pth, 'calib-%s-4x4_lookup_no_switch.txt' % (date)) , calibration_lookup)\n savetxt(os.path.join(pth, 'calib-%s-4x4_3x3_no_switch.txt' % (date)) , calibration_matrix)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def compute_magnetic_field(self, coords, params={}, basis=\"rpz\"):","def get_probeLocs_calib_setup_cm(dir, num_probes = 16):\n position_vectors = [[0] * 3 for i in range(num_probes)]\n\n #every x postion\n\n # Convert to meters\n x_pos = [-4.25*2.54, -4.25*2.54, 4.24*2.54, 4.24*2.54]\n y_pos = [-4.25*2.54, 4.24*2.54, 4.24*2.54, -4.25*2.54]\n z_pos = [-2.25*2.54, -0.75*2.54, 0.75*2.54, 2.25*2.54]\n x = 0\n for i in range(num_probes):\n if(i%4 ==0 and i>0):\n x+=1\n position_vectors[i][0] =x_pos[x]\n position_vectors[i][1] = y_pos[x]\n position_vectors[i][2] =z_pos[i%4]\n # print(position_vectors[i][0])\n\n \"\"\" Now take into account the direction\n r shots : x,y,z - > r,t,z\n t shots : x,y,z - > r,t,z\n z shots : x,y,z - > r,t,z\n \"\"\"\n if dir ==2 :#r\n # don't need to switch anything\n return position_vectors\n if dir == 0:#t\n # looks like -90 degree rotation about y-axis of probe coil orientation, so switch x and z\n position_vectors[:][0], position_vectors[:][2] = position_vectors[:][2], position_vectors[:][0]\n return position_vectors\n if dir ==1:#z\n # also like -90 degree rotation, switch x and z\n position_vectors[:][0], position_vectors[:][2] = position_vectors[:][2], position_vectors[:][0]\n return position_vectors\n\n return position_vectors","def get_probeLocs_calib_setup(dir, num_probes = 16):\n position_vectors = [[0] * 3 for i in range(num_probes)]\n\n #every x postion\n\n # Convert to meters\n x_pos = [-4.25*1e-3*25.4, -4.25*1e-3*25.4, 4.24*1e-3*25.4, 4.24*1e-3*25.4]\n y_pos = [-4.25*1e-3*25.4, 4.24*1e-3*25.4, 4.24*1e-3*25.4, -4.25*1e-3*25.4]\n z_pos = [-2.25*1e-3*25.4, -0.75*1e-3*25.4, 0.75*1e-3*25.4, 2.25*1e-3*25.4]\n x = 0\n for i in range(num_probes):\n if(i%4 ==0 and i>0):\n x+=1\n position_vectors[i][0] =x_pos[x]\n position_vectors[i][1] = y_pos[x]\n position_vectors[i][2] =z_pos[i%4]\n # print(position_vectors[i][0])\n\n \"\"\" Now take into account the direction\n r shots : x,y,z - > r,t,z\n t shots : x,y,z - > r,t,z\n z shots : x,y,z - > r,t,z\n \"\"\"\n if dir ==2 :#r\n # don't need to switch anything\n return position_vectors\n if dir == 0:#t\n # looks like -90 degree rotation about y-axis of probe coil orientation, so switch x and z\n position_vectors[:][0], position_vectors[:][2] = position_vectors[:][2], position_vectors[:][0]\n return position_vectors\n if dir ==1:#z\n # also like -90 degree rotation, switch x and z\n position_vectors[:][0], position_vectors[:][2] = position_vectors[:][2], position_vectors[:][0]\n return position_vectors\n\n return position_vectors","def calcMagneticFieldMap(self):\n # Normalised b-field (note lower case)\n self.solenoid.calcMagneticFieldMap()\n self.b = lambda z: self.solenoid.B_interp(z) * -e / (2 * m * c)\n self.calc_level = CALC_B_MAP","def get_x_y_z(drone, p, q, r):\n num_cameras = 2\n camera_constants = [0,math.pi/2]\n rads = np.zeros(num_cameras)\n phis = np.zeros(num_cameras)\n d = np.zeros(num_cameras)\n theta = np.zeros(num_cameras)\n Hs = np.zeros(num_cameras)\n s = 12\n HFOV = math.pi/4\n VFOV = 5*math.pi/36\n HPIX = 1280\n VPIX = 720\n #loop one, where we increment over camera number, and\n # get new information\n\n cent = calculate_centroid(p,q,r)\n for camera_num in range(num_cameras):\n\n A,B = find_a_and_b(p[camera_num],q[camera_num],r[camera_num],cent[camera_num])\n a = find_a(A,B)\n d_in = find_inner_d(a, s)\n angle_c = find_angle_c(a)\n alpha = find_alpha(HFOV, HPIX, A)\n w = find_w(angle_c, s)\n d_out = find_outer_d(w,alpha,a)\n pointy_front = is_point_front(r[camera_num],q[camera_num],p[camera_num],cent[camera_num])\n d[camera_num] = find_d(d_in,d_out,pointy_front)\n theta[camera_num] = find_theta(angle_c,A,B,camera_constants[camera_num])\n k = find_k(drone[camera_num], cent[camera_num])\n angle_k = find_angle_k(k, HFOV, HPIX)\n phi = find_phi(theta[camera_num], angle_k)\n rad = find_r(d[camera_num], angle_k)\n phis[camera_num] = phi\n rads[camera_num] = rad\n\n # end of first loop\n\n cosphis = np.cos(phis)\n sinphis = np.sin(phis)\n big_matrix = np.column_stack((cosphis,sinphis))\n points = np.zeros((int(num_cameras*(num_cameras-1)/2),2))\n i = 0\n for pair in itertools.combinations(range(num_cameras), 2):\n matrix_a = np.vstack((big_matrix[pair[0]],big_matrix[pair[1]]))\n vec_b = np.hstack((rads[pair[0]],rads[pair[1]]))\n point = np.linalg.solve(matrix_a, vec_b)\n points[i] = point\n i += 1\n drone_pos = np.mean(points,axis=0)\n\n # start of third loop\n for camera_num in range(num_cameras):\n d_prime = find_d_prime(d[camera_num], theta[camera_num], drone_pos)\n P,Q,M,N = find_P_Q_M_N(p[camera_num],q[camera_num],r[camera_num])\n h = find_h(d[camera_num],P,Q,M,N)\n angle_4 = find_angle_4(h,d[camera_num])\n Y = find_Y(drone[camera_num], cent[camera_num])\n angle_5 = find_angle_5(Y, VFOV, VPIX)\n angle_6 = angle_5 - angle_4\n h_prime = find_h_prime(d_prime, angle_6)\n Hs[camera_num] = h + h_prime\n drone_h = np.mean(H)\n return np.append(drone_pos,drone_h)","def field ( self , xyz ) :\n return self._ilhcbmagnet.fieldVector ( xyz )","def normal_vectors(ATOM_list, frame, number_of_atoms, number_of_molecules, number_of_vectors, centerlist, referencelist, boxX, boxY, boxZ):\t\n\tNORMAL_VECTORS_out=open(\"normalvectors.xyz\",'a')\n\t\n\tNORMAL_VECTORS_check=open(\"check_normalvectors.xyz\",'a')\n\t\n\tANGLEDIST_VECTORS_out=open(\"angle_dist_vectors.xyz\",'a')\n\t\n\t\n\tVorzugsrichtung_out=open(\"sum_over_all_normalvectors.dat\",'a')\n\t\n\t\n\t\n\tNORMAL_VECTORS_check.write(str( (number_of_vectors*(2 + int(len(referencelist))) )*number_of_molecules )+'\\n')\n\tNORMAL_VECTORS_check.write(str(frame)+'\\n')\n\t\n\tNORMAL_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\n')\n\tNORMAL_VECTORS_out.write(str(frame)+'\\n')\n\n\tANGLEDIST_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\n')\n\tANGLEDIST_VECTORS_out.write(str(frame)+'\\n')\n\t\n\tvorzugsvektor = np.asarray([0,0,0])\n\treference=0\n\t\n\t\n\tfor l in range(0,number_of_molecules):\n\t\tfor vec_count in range(0,number_of_vectors):\n\t\t\tr = []\n\t\t\t#get the 'middle' of the DPI molecule\n\t\t\t\n\t\t\n\t\t\t#get geometric center\n\t\t\tcenter=np.asarray([0,0,0])\n\t\t\t#append all vectors defining the center\n\t\t\tfor i in range(len(centerlist[vec_count])):\n\t\t\t\t# x y z\n\t\t\t\tr.append( np.asarray( [ ATOM_list[centerlist[vec_count][i] + reference][1],ATOM_list[centerlist[vec_count][i] + reference][2],ATOM_list[centerlist[vec_count][i] + reference][3] ] ) ) \n\t\t\t\tcenter = center + r[i]\n\t\t\tcenter = center / len(centerlist[vec_count])\n\t\t\n\t\t\t#calculate all reference vectors\n\t\t\tr=[]\n\t\t\tfor i in range(len(referencelist[vec_count])):\n\t\t\t\tr.append(np.asarray( [ ATOM_list[referencelist[vec_count][i] + reference][1],ATOM_list[referencelist[vec_count][i] + reference][2],ATOM_list[referencelist[vec_count][i] + reference][3] ] ) )\n\t\t\n\t\t\t#get the cross products\n\t\t\tnormal_vec= np.asarray([0,0,0])\n\t\t\tfor i in range(len(r)):\n\t\t\t\tif (i<(len(r)-1)):\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tif ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]+boxX) ) and ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx = r[i][0]-center[0]\n\t\t\t\t\telif (abs(r[i][0]-center[0]+boxX) < abs(r[i][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx = r[i][0]-center[0]+boxX\n\t\t\t\t\telse:\n\t\t\t\t\t\tdx = r[i][0]-center[0]-boxX\n\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]+boxY) ) and ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy = r[i][1]-center[1]\n\t\t\t\t\telif (abs(r[i][1]-center[1]+boxY) < abs(r[i][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy = r[i][1]-center[1]+boxY\n\t\t\t\t\telse:\n\t\t\t\t\t\tdy = r[i][1]-center[1]-boxY\n\t\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]+boxZ) ) and ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz = r[i][2]-center[2]\n\t\t\t\t\telif (abs(r[i][2]-center[2]+boxZ) < abs(r[i][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz = r[i][2]-center[2]+boxZ\n\t\t\t\t\telse:\n\t\t\t\t\t\tdz = r[i][2]-center[2]-boxZ\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tif ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]+boxX) ) and ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]\n\t\t\t\t\telif (abs(r[i+1][0]-center[0]+boxX) < abs(r[i+1][0]-center[0]-boxX) ):\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]+boxX\n\t\t\t\t\telse:\n\t\t\t\t\t\tdx2 = r[i+1][0]-center[0]-boxX\n\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]+boxY) ) and ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]\n\t\t\t\t\telif (abs(r[i+1][1]-center[1]+boxY) < abs(r[i+1][1]-center[1]-boxY) ):\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]+boxY\n\t\t\t\t\telse:\n\t\t\t\t\t\tdy2 = r[i+1][1]-center[1]-boxY\n\t\t\t\t\t\t\n\t\t\t\t\tif ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]+boxZ) ) and ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]\n\t\t\t\t\telif (abs(r[i+1][2]-center[2]+boxZ) < abs(r[i+1][2]-center[2]-boxZ) ):\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]+boxZ\n\t\t\t\t\telse:\n\t\t\t\t\t\tdz2 = r[i+1][2]-center[2]-boxZ\n\t\t\t\t\t\n\t\t\t\t\tvec1=np.asarray([dx,dy,dz])\n\t\t\t\t\tvec2=np.asarray([dx2,dy2,dz2])\n\t\t\t\t\t#dy = r[i][1]-center[1]\n\t\t\t\t\t#dz = r[i][2]-center[2]\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\n\t\t\t\t\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm( np.cross(vec1, vec2) )\n\t\t\t\telif ( i==len(r) ):\n\t\t\t\t\t\n\t\t\t\t\t#minimum image convenction\n\t\t\t\t\tdx = min( abs(r[i][0]-center[0]), abs(r[i][0]-center[0]+boxX), abs(r[i][0]-center[0]-boxX) )\n\t\t\t\t\tdy = min( abs(r[i][1]-center[1]), abs(r[i][1]-center[1]+boxX), abs(r[i][1]-center[1]-boxX) )\n\t\t\t\t\tdz = min( abs(r[i][2]-center[2]), abs(r[i][2]-center[2]+boxX), abs(r[i][2]-center[2]-boxX) )\n\t\t\t\t\t\n\t\t\t\t\tdx2 = min( abs(r[0][0]-center[0]), abs(r[0][0]-center[0]+boxX), abs(r[0][0]-center[0]-boxX) )\n\t\t\t\t\tdy2 = min( abs(r[0][1]-center[1]), abs(r[0][1]-center[1]+boxX), abs(r[0][1]-center[1]-boxX) )\n\t\t\t\t\tdz2 = min( abs(r[0][2]-center[2]), abs(r[0][2]-center[2]+boxX), abs(r[0][2]-center[2]-boxX) )\n\t\t\t\t\t\n\t\t\t\t\tvec1=np.asarray([dx,dy,dz])\n\t\t\t\t\tvec2=np.asarray([dx2,dy2,dz2])\n\t\t\t\t\t#dy = r[i][1]-center[1]\n\t\t\t\t\t#dz = r[i][2]-center[2]\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\n\t\t\t\t\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm(np.cross(vec1, vec2))\n\t\t\t\t\t#normal_vec = normal_vec + np.cross(r[i]-center, r[0]-center) \n\t\t\n\t\t\t#normalize\n\t\t\tnormal_vec = normal_vec/np.linalg.norm(normal_vec)\n\t\t\n\t\t\t#\t#direction vectors\n\t\t\t#\tdir_vec1 = np.asarray([r[6][0],r[6][1],r[6][2]])\n\t\t\t#\tdir_vec2 = np.asarray([r[7][0],r[7][1],r[7][2]])\n\t\t\t#\tdir_vec3 = np.asarray([r[8][0],r[8][1],r[8][2]])\n\t\t\t#\tdir_vec4 = np.asarray([r[9][0],r[9][1],r[9][2]])\n\t\t\t#\tdir_vec = (dir_vec1 + dir_vec2 + dir_vec3 + dir_vec4)/4.0\n\t\t\t#\tdir_vec = mittelpunkt_dpi - dir_vec\t\t\t\n\n\t\t\t#change direction according to bending\n\t\t\t#\tif normal_vec[0]!=0 and dir_vec[0]!=0:\n\t\t\t#\t\tif normal_vec[0]/abs(normal_vec[0])!=dir_vec[0]/abs(dir_vec[0]):\n\t\t\t#\t\t\tnormal_vec[0] = -normal_vec[0]\n\t\t\t#\tif normal_vec[1]!=0 and dir_vec[1]!=0:\n\t\t#\t\t\tif normal_vec[1]/abs(normal_vec[1])!=dir_vec[1]/abs(dir_vec[1]):\n\t\t#\t\t\t\tnormal_vec[1] = -normal_vec[1]\n\t\t#\t\tif normal_vec[2]!=0 and dir_vec[2]!=0:\n\t\t#\t\t\tif normal_vec[2]/abs(normal_vec[2])!=dir_vec[2]/abs(dir_vec[2]):\n\t\t#\t\t\t\tnormal_vec[2] = -normal_vec[2]\n\n\t\t\t\n\t\t\t#check for a vorzugsvektor\n\t\t\tvorzugsvektor = vorzugsvektor + normal_vec\n\t\t\tNORMAL_VECTORS_out.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_out.write('O' +'\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tANGLEDIST_VECTORS_out.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tANGLEDIST_VECTORS_out.write('H' +'\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('C' +'\t'+ str((center)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('O' +'\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tNORMAL_VECTORS_check.write('H' +'\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\n')\n\t\t\tfor i in range(len(referencelist[vec_count])):\n\t\t\t\tNORMAL_VECTORS_check.write('N' +'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][1])+'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][2])+'\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][3])+ '\\n')\n\n\t\t#always skip 1 entire molecule forward\n\t\treference=reference + number_of_atoms/number_of_molecules\n\t\t\n\t#calculate a vorzugsvektor as sum over DIPBI normal vectors divided by number of DPBI vectors\n\tvorzugsvektor = vorzugsvektor/(number_of_vectors*frames*number_of_molecules)\n\tVorzugsrichtung_out.write(str(frame) + ' ' + str((vorzugsvektor)).replace('[', '').replace(']','')+'\\n')\n\tNORMAL_VECTORS_out.close()\n\tNORMAL_VECTORS_check.close()\n\treturn","def find_point(ball_loc, direction, kick_positions, positions):\n # unpack leg positions\n kick_x, kick_y, kick_z = kick_positions\n pos_x, pos_y, pos_z = positions \n # ball position relative to the kicking foot\n ball_loc = [100, -100.55154471, 0.09521921 ]\n # all boundaries for the kicking leg\n min_x = int(kick_positions[0] - 75) #- 0.13641\n max_x = int(kick_positions[0] +75)\n #min_y = int(kick_positions[1] - 75) #0.1340\n #max_y = int(kick_positions[1] + 75)#0.1014\n min_y = -140\n max_y = -90\n #min_z = int(kick_positions[2] ) #0.05\n #max_z = int(kick_positions[2] + 50) #0.1526\n min_z = 40\n max_z = 75\n\n # make ball position in world_space coordinates\n bal_x = ball_loc[0]\n bal_y = ball_loc[1]\n bal_z = ball_loc[2]\n # make direction in world_space coordinates\n #direction_x = kick_x + direction[0]\n #direction_y = kick_y + direction[1]\n #direction_z = kick_z + direction[2]\n direction = np.matrix([ [direction[0]], [direction[1]], [direction[2]]])\n # no retraction when other leg is there(change these values)\n #if( pos_y < max_y or pos_y > min_y):\n # if( abs(pos_y - max_y) > abs(pos_y - min_y)):\n # min_y = pos_y\n # else:\n # max_y = pos_y\n best_pos = 0\n # make matrix of the world_space ball and direction coordinates\n bal_loc = np.matrix([[bal_x], [bal_y], [bal_z]])\n #direction = np.matrix([[direction_x], [direction_y], [direction_z]])\n for x in xrange(min_x, max_x, 10):\n for y in xrange(min_y, max_y, 10):\n for z in xrange(min_z, max_z, 10):\n global x_pos\n global y_pos\n global z_pos\n x_pos = x_pos + [x]\n y_pos = y_pos + [y]\n z_pos = z_pos + [z]\n contact_point, value = retractionPoint(bal_loc, np.matrix([[x], [y],\n [z]]), direction, 1)\n #print \"contact\", contact_point\n if value > best_pos:\n best_pos = value\n kick_x = x\n kick_y = y\n kick_z = z\n \n contact = [contact_point[0,0], contact_point[1,0], contact_point[2,0]]\n return contact, [kick_x, kick_y, kick_z]","def genImgVfixedPos(filename=None,seeing=0,npix=None,zenith=0,filter='r', theta=0., corrector='corrector',x=None,y=None,z=None,suband=None):\n datalist = []\n hdrlist = []\n xmm,ymm = np.meshgrid([-120,-80,-40,-20,0,20,40,80,120],[-120,-80,-40,-20,0,20,40,80,120])\n xmm = xmm.flatten()\n ymm = ymm.flatten()\n Nstar = len(xmm)\n for i in range(Nstar):\n res = decamspot(xmm=xmm[i],ymm=ymm[i],seeing=seeing,npix=npix,zenith=zenith,filter=filter, theta=theta, corrector=corrector,x=x,y=y,z=z,suband=suband)\n datalist.append(res[0])\n hdrlist.append(res[1])\n data = np.array(datalist)\n if filename is not None:\n hdu = pf.PrimaryHDU(data)\n hdu.header.set('RAYPATT',raypattern)\n hdu.header.set('NPIX',npix)\n hdu.header.set('SCALE',scale)\n hdu.header.set('FWHM',fwhm)\n hdu.header.set('ZENITH',zenith)\n hdu.header.set('FILTER',filter)\n hdu.header.set('THETA',theta)\n hdu.header.set('CORRT',corrector)\n if x != None:\n hdu.header.set('X',x)\n if y != None:\n hdu.header.set('Y',y)\n if z != None:\n hdu.header.set('Z',z)\n if seeing != 0.:\n hdu.header.set('s_fwhm',seeing[0])\n hdu.header.set('e1',seeing[1])\n hdu.header.set('e2',seeing[2])\n if os.path.exists(filename):\n os.system('rm '+filename)\n hdu.writeto(filename)\n else:\n hdu.writeto(filename) \n return data,hdrlist","def aperture_phot(self,data,x,y,v):\n r = np.sqrt((x-self.avg_map_fits['Values'][1])**2 + (y-self.avg_map_fits['Values'][3])**2)\n \n inner = (r < 8./60.) & np.isfinite(data) \n outer = (r > 8.5/60.) & (r < 12./60.) & np.isfinite(data)\n\n annu = np.nanmedian(data[outer])\n annu_rms = np.nanstd(data[outer])\n flux = np.sum(data[inner]) - annu*np.sum(inner)\n\n c = 3e8\n kb=1.38e-23\n beam = (1./60.*np.pi/180.)**2\n factor = 2*kb*(v*1e9/c)**2 * beam * 1e26\n return flux*factor, annu_rms*np.sqrt(np.sum(inner))*factor","def find_position(self, xv, yv):\n # Convert position in spheric coord\n phi = xv*self.FOV_img/360/self.img_res\n theta = yv*self.FOV_img_Y/180/self.img_res_Y\n phi2 = phi+(360-self.FOV_img)/2\n theta2 = theta+(180-self.FOV_img_Y)/2\n\n u, v, w = spheric2cart(np.radians(theta2), np.radians(phi2)) # give cartesian coord of pixel\n\n # ignore errors due to /0 -> inf, -inf\n # divide (w/v) and invalid arctan2()\n with np.errstate(all='ignore'): # OPTIMIZE: see comment about pi = -pi and don't matter if -0 or 0 -> just replace by pi\n beta = -np.arctan(w/v)\n# beta2 = -np.arctan2(w, v)\n\n# v2 = np.dot(rotation_matrix(beta), [u, v, w]) # take 3*3 created matrix and aplly to vector\n matrix = rotation_matrix(beta)\n u2 = matrix[0, 0]*u\n v2 = matrix[1, 1]*v+matrix[1, 2]*w\n w2 = matrix[2, 1]*v+matrix[2, 2]*w\n _, seen_angle = cart2spheric(u2, v2, w2) # return phi in equator \"projection\"\n\n seen_angle = np.degrees(seen_angle)\n seen_angle = np.mod(seen_angle, 360) # define phi [0, 360]\n\n# seen_angle[seen_angle > 360] -= 360\n deviated_angle = np.zeros(seen_angle.shape)\n deviated_angle[seen_angle < 180] = self.interpolation(seen_angle[seen_angle < 180])\n deviated_angle[seen_angle >= 180] = 360 - self.interpolation(360-seen_angle[seen_angle >= 180])\n# np.flip(deviated_angle, 1) \" mais probleme overlap entre left et right\n\n theta = pi/2# *np.ones(deviated_angle.shape)\n phi = np.radians(deviated_angle)\n u3, v3, w3 = spheric2cart(theta, phi) #get cart coord of deviated pixel\n\n matrix = rotation_matrix(-beta)\n u4 = matrix[0, 0]*u3\n v4 = matrix[1, 1]*v3+matrix[1, 2]*w3\n w4 = matrix[2, 1]*v3+matrix[2, 2]*w3\n\n theta, phi = cart2spheric(u4, v4, w4) #give spheric coord of deviated pixel\n\n theta, phi = np.degrees(theta), np.degrees(phi)\n\n phi -= (360-self.FOV_img)/2\n theta -= (180-self.FOV_img_Y)/2\n\n with np.errstate(all='ignore'): # OPTIMIZE\n phi = np.mod(phi, 360) # define phi [0, 360]\n theta = np.mod(theta, 180) # define phi [0, 360]\n\n phi[phi == 360] = 0\n xv2 = phi*360/self.FOV_img*self.img_res\n yv2 = theta*180/self.FOV_img_Y*self.img_res_Y #give deviated angle pixel position\n\n xv2[np.isnan(xv2)] = -1\n yv2[np.isnan(yv2)] = -1\n\n xv2 = np.array(xv2, dtype=int)\n yv2 = np.array(yv2, dtype=int)\n\n return xv2, yv2","def test_cspad_xy_at_z():\n ## 'CxiDs1.0:Cspad.0)' or 'DscCsPad'\n basedir = '/reg/g/psdm/detector/alignment/cspad/calib-cxi-camera1-2014-09-24/'\n fname_geometry = basedir + '2016-06-03-geometry-cxi06216-r25-camera1-z175mm.txt'\n fname_data = basedir + '2016-06-03-chun-cxi06216-0025-DscCsPad-max.txt'\n\n geometry = GeometryAccess(fname_geometry, pbits=0o377)\n\n # get pixel coordinate index arrays:\n xyc = xc, yc = 1000, 1000\n #rows, cols = geometry.get_pixel_coord_indexes(xy0_off_pix=xyc)\n #rows, cols = geometry.get_pixel_coord_indexes(do_tilt=True)\n #rows, cols = geometry.get_pixel_xy_inds_at_z(zplane=None, xy0_off_pix=xyc)\n rows, cols = geometry.get_pixel_xy_inds_at_z(zplane=150000)\n\n root, ext = os.path.splitext(fname_data)\n arr = np.load(fname_data) if ext == '.npy' else np.loadtxt(fname_data, dtype=np.float)\n\n #logger.info('arr.shape=', arr.shape\n arr.shape= (32,185,388)\n\n #ave, rms = arr.mean(), arr.std()\n #amp_range = (ave-rms, ave+3*rms)\n amp_range = (0, 1000)\n logger.info('amp_range:' + str(amp_range))\n\n logger.info('shapes rows: %s cols: %s weight: %s' % (str(rows.shape), str(cols.shape), str(arr.shape)))\n img = img_from_pixel_arrays(rows,cols,W=arr)\n\n axim = gg.plotImageLarge(img,amp_range=amp_range)\n gg.move(500,10)\n gg.show()","def get_sigma_map(start_x = 0,field_height=100,field_width=100,viewing_distance=12.0,screen_pixel_size=0.282,debug=False):\n start_x_pixels = np.round(get_pixels_at_degrees(degrees=start_x,viewing_distance=viewing_distance,screen_pixel_size=screen_pixel_size))\n optical_nodal_distance = 17.0 # mm from lens to fovea\n viewing_distance_inches = viewing_distance\n viewing_distance = viewing_distance * 25.4 # mm\n center_y, center_x = 0,0\n x_coords = (start_x_pixels + np.arange(-field_width/2.0,field_width/2,1))*screen_pixel_size\n y_coords = np.arange(-field_height/2.0,field_height/2,1)*screen_pixel_size\n x,y = np.meshgrid(x_coords,y_coords)\n coords = np.vstack((y.ravel(),x.ravel())).T\n\n image_dist = cdist(np.matrix([center_y,center_x]),coords)\n fovea_dist = (np.pi/180.0)*optical_nodal_distance*get_degrees_at_pixels(pixels=image_dist/screen_pixel_size,viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size)\n midget_dendritic_field_diameter_micrometers = 8.64 * np.power(fovea_dist,1.04) # midget from Dacey and Peterson, 1994\n midget_dendritic_field_diameter_millimeters = midget_dendritic_field_diameter_micrometers/1000.0\n midget_projected_field_diameter_on_image = get_pixels_at_degrees(degrees=start_x+np.degrees(np.arctan((midget_dendritic_field_diameter_millimeters/2.0)/optical_nodal_distance)),viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size) - get_pixels_at_degrees(degrees=start_x-np.degrees(np.arctan((midget_dendritic_field_diameter_millimeters/2.0)/optical_nodal_distance)),viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size)\n\n midget_sigma_map = midget_projected_field_diameter_on_image / 6.0 # ensures 99.7% of dendrites are connected to field diameter\n midget_sigma_map = midget_sigma_map.reshape((field_height,field_width))\n\n parasol_dendritic_field_diameter_micrometers = 70.2 * np.power(fovea_dist,0.65) # parasol from Dacey and Peterson, 1994\n parasol_dendritic_field_diameter_millimeters = parasol_dendritic_field_diameter_micrometers/1000.0\n parasol_projected_field_diameter_on_image = get_pixels_at_degrees(degrees=start_x+np.degrees(np.arctan((parasol_dendritic_field_diameter_millimeters/2.0)/optical_nodal_distance)),viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size) - get_pixels_at_degrees(degrees=start_x-np.degrees(np.arctan((parasol_dendritic_field_diameter_millimeters/2.0)/optical_nodal_distance)),viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size)\n parasol_sigma_map = parasol_projected_field_diameter_on_image / 6.0 # ensures 99.7% of dendrites are connected to field diameter\n parasol_sigma_map = parasol_sigma_map.reshape((field_height,field_width))\n\n return midget_sigma_map,parasol_sigma_map","def magnetic_field(self, xyz):\n dxyz = self.vector_distance(xyz)\n r = spatial.repeat_scalar(self.distance(xyz))\n kr = self.wavenumber * r\n ikr = 1j*kr\n\n front_term = (\n self.current * self.length / (4 * np.pi * r**2) * (ikr + 1) *\n np.exp(-ikr)\n )\n return -front_term * self.cross_orientation(dxyz) / r","def B_outside_sphere(sphere_radius, dipole_pos, dipole_moment, detector_positions):\n\n\n pos = np.array(dipole_pos, dtype=float)*1e-3\n moment = np.array(dipole_moment, dtype=float)\n detector = np.array(detector_positions, dtype=float)*1e-3\n\n assert np.all(np.linalg.norm(detector_positions, axis=1) >sphere_radius), \"All points must be outside the sphere\"\n\n assert np.all(np.linalg.norm(dipole_pos) <sphere_radius), \"Dipole must be outside sphere\"\n\n B = np.zeros(detector_positions.shape, dtype=float)\n\n for ii, r in enumerate(detector):\n norm_r = np.linalg.norm(r)\n\n r_0 = pos\n norm_r0 = np.linalg.norm(pos)\n\n a = r - r_0\n norm_a = np.linalg.norm(a)\n\n F = norm_a * (norm_r * norm_a + norm_r**2 - r_0.dot(r))\n\n grad_F = (norm_r**(-1) * norm_a**2 + norm_a**(-1) * a.dot(r) + 2 * norm_a + 2 * norm_r) * r - \\\n (norm_a + 2 * norm_r + norm_a**(-1) * a.dot(r)) * r_0\n\n B[ii, :] = (4 * np.pi * 1e-7) /\\\n (4 * np.pi * F**2) * (F * np.cross(moment, r_0) - np.dot(np.cross(moment, r_0), r) * grad_F)\n\n return B","def __call__(self, coords, params={}, basis=\"rpz\"):\n return self.compute_magnetic_field(coords, params, basis)","def param2pos( param, stickguy ):\n\n hip_pos = np.array([0.0, param[0]])\n spine_vec = np.array([0.0, 1.0])\n spine_vec = rotate(spine_vec, param[1])\n neck_pos = hip_pos + spine_vec\n basic_arm_vec = -0.6*spine_vec\n arm_vec = rotate(basic_arm_vec, param[2])\n left_elbow_pos = neck_pos + arm_vec\n arm_vec = rotate(arm_vec, param[3])\n left_hand_pos = left_elbow_pos + arm_vec\n lad = np.array([neck_pos,left_elbow_pos,left_hand_pos])\n stickguy.left_arm.set_data(lad[:,0],lad[:,1])\n\n arm_vec = rotate(basic_arm_vec, param[4])\n right_elbow_pos = neck_pos + arm_vec\n arm_vec = rotate(arm_vec, param[5])\n right_hand_pos = right_elbow_pos + arm_vec\n rad = np.array([neck_pos,right_elbow_pos,right_hand_pos])\n stickguy.right_arm.set_data(rad[:,0],rad[:,1])\n\n neck_vec = 0.3*spine_vec\n neck_vec = rotate( neck_vec, param[6])\n head_pos = neck_pos + neck_vec\n sd = np.array([hip_pos,neck_pos,head_pos])\n stickguy.spine.set_data(sd[:,0],sd[:,1])\n\n basic_leg_vec = (0.0,-0.7)\n leg_vec = rotate(basic_leg_vec, param[7])\n left_knee_pos = hip_pos + leg_vec\n leg_vec = rotate(leg_vec, param[8])\n left_foot_pos = left_knee_pos + leg_vec\n lld = np.array([hip_pos,left_knee_pos,left_foot_pos])\n stickguy.left_leg.set_data(lld[:,0],lld[:,1])\n\n leg_vec = rotate(basic_leg_vec, param[9])\n right_knee_pos = hip_pos + leg_vec\n leg_vec = rotate(leg_vec, param[10])\n right_foot_pos = right_knee_pos + leg_vec\n rld = np.array([hip_pos,right_knee_pos,right_foot_pos])\n stickguy.right_leg.set_data(rld[:,0],rld[:,1])\n\n return","def getMagneticFieldMap(self):\n return self.solenoid.B_interp(self.z_array)","def Ez_area(position, angle, detect):\n# a = range(round(-2*Ez_height),round(2*Ez_height))\n# b = range(round(-2*Ez_height),round(2*Ez_height))\n# a_valid = []\n# b_valid= []\n \n # These are the grid points in a coordinate system based on the Ez's angle\n if detect:\n a_valid = [-11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6]\n b_valid = [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3]\n else:\n a_valid = [-9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]#[-19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9]\n b_valid = [-4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3, -2, -1, 0, 1, 2]#[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4]\n positions = []\n# for i in a:\n# for j in b:\n# if (i > ((Ez_width/2)-Ez_height-detect_length) and abs(j) < (Ez_width/2+detect_length) and i < 0) or (i > 0 and np.sqrt(i**2 + j**2) < Ez_width/2+detect_length):\n# a_valid.append(i)\n# b_valid.append(j)\n# print('AAAA', a_valid)\n# print(' ')\n# print('BBBB', b_valid)\n# print(' ')\n \n # This is a coordinate transfromation to x,y\n for i in range(len(a_valid)):\n positions.append((int(round(a_valid[i]*np.cos(angle) + b_valid[i]*np.sin(angle) + position[0])), int(round(a_valid[i]*np.sin(angle) - b_valid[i]*np.cos(angle) + position[1]))))\n return positions","def calculate_beam_xy(self):\n info = []\n\n # Import relevant info\n pixel_size = self.info.pixel_size\n for i in [j.final for j in self.final_objects]:\n try:\n info.append(\n [\n i,\n i[\"beamX\"],\n i[\"beamY\"],\n i[\"wavelength\"],\n i[\"distance\"],\n (i[\"a\"], i[\"b\"], i[\"c\"], i[\"alpha\"], i[\"beta\"], i[\"gamma\"]),\n ]\n )\n except IOError as e:\n print(\"IOTA ANALYSIS ERROR: BEAMXY failed! \", e)\n pass\n\n # Calculate beam center coordinates and distances\n beamX = [i[1] for i in info]\n beamY = [j[2] for j in info]\n beam_dist = [\n math.hypot(i[1] - np.median(beamX), i[2] - np.median(beamY)) for i in info\n ]\n beam_dist_std = np.std(beam_dist)\n img_list = [\n [i[0], i[1], i[2], i[3], i[4], i[5], j]\n for i, j in list(zip(info, beam_dist))\n ]\n\n # Separate out outliers\n outliers = [i for i in img_list if i[3] > 2 * beam_dist_std]\n clean = [i for i in img_list if i[3] <= 2 * beam_dist_std]\n cbeamX = [i[1] for i in clean]\n cbeamY = [j[2] for j in clean]\n obeamX = [i[1] for i in outliers]\n obeamY = [j[2] for j in outliers]\n\n # Calculate median wavelength, detector distance and unit cell params from\n # non-outliers only\n wavelengths = [i[3] for i in clean]\n distances = [i[4] for i in clean]\n cells = [i[5] for i in clean]\n\n wavelength = np.median(wavelengths)\n det_distance = np.median(distances)\n a = np.median([i[0] for i in cells])\n b = np.median([i[1] for i in cells])\n c = np.median([i[2] for i in cells])\n\n # Calculate predicted L +/- 1 misindexing distance for each cell edge\n aD = det_distance * math.tan(2 * math.asin(wavelength / (2 * a)))\n bD = det_distance * math.tan(2 * math.asin(wavelength / (2 * b)))\n cD = det_distance * math.tan(2 * math.asin(wavelength / (2 * c)))\n\n return (\n beamX,\n beamY,\n cbeamX,\n cbeamY,\n obeamX,\n obeamY,\n beam_dist,\n [i[4] for i in info],\n aD,\n bD,\n cD,\n pixel_size,\n )","def stempot(self,xmax,ymax,nx,ny,atms,pixelshift,scalefactor):\n #zed=2 for rutherford scattering of the nucleus, less for screening\n zed = 1.7\n\n ix = numpy.arange(1.0,nx)\n iy = numpy.arange(1.0,ny)\n dx = xmax/nx\n dy = ymax/ny\n rx = numpy.arange(0,xmax-dx,dx)\n ry = numpy.arange(0,ymax-dy,dy)\n\n Zatom = atms.get_atomic_numbers()\n #translate atoms such that the center of mass is in the center of the computational cell\n com = atms.get_center_of_mass()\n #com = [ 44.40963074 , 44.65497562 , 44.90406073] #for AuNP\n #com = numpy.array(com)\n #print 'com',com -0.149836425, 0.29967285, 0\n #com += [0.41205016875, 0.6742639125, 0] #for rotated line profile \n #com += [-0.149836425, 0.29967285, 0] #for AuNP\n #com += pixelshift\n #print 'com+pixelshift',com\n cop = xmax/2.0\n trans = [cop-i for i in com]\n atms.translate(trans)\n positions=atms.get_positions()\n ax=[]\n ay=[]\n az=[]\n for o,t,h in positions:\n ax.append(o)\n ay.append(t)\n az.append(h)\n ax = numpy.array(ax)\n ay = numpy.array(ay)\n az = numpy.array(az)\n amax = len(Zatom)\n\n #find boundaries of slice\n axmin = min(ax)\n axmax = max(ax)\n aymin = min(ay)\n aymax = max(ay)\n\n V= numpy.zeros((nx,ny))\n\n #map x and y coords of the atoms to the nearest grid points\n #A fraction of the atom must be assigned to the closest gridpoints\n #to avoid sum and difference frequencies appearing in the image\n #grid point to the left of the atom\n ix = numpy.array([math.floor(axi/dx) for axi in ax])\n #apply periodic boundary conditions\n iax = numpy.array([math.fmod(iaxi,nx) for iaxi in ix])\n ibx = numpy.array([math.fmod(iaxi+1,nx) for iaxi in ix])\n #fraction of atom at iax\n fax = numpy.array([1-math.fmod((axi/dx),1 ) for axi in ax])\n #grid point above the atom\n iy = numpy.array([math.floor(ayi/dy) for ayi in ay])\n #apply periodic boundary conditions\n iay = numpy.array([math.fmod(iayi,ny) for iayi in iy])\n iby = numpy.array([math.fmod(iayi+1,ny) for iayi in iy])\n #fraction of atom at iay \n fay = numpy.array([1-math.fmod((ayi/dy),1 ) for ayi in ay])\n #Add each atom to the potential grid\n V1 = numpy.array([fax[i] * fay[i] * (Zatom[i]**zed) for i in range(len(fax))])\n V2 = numpy.array([(1-fax[i]) * fay[i] * (Zatom[i]**zed) for i in range(len(fax))])\n V3 = numpy.array([fax[i] * (1-fay[i]) * (Zatom[i]**zed) for i in range(len(fax))])\n V4 = numpy.array([(1-fax[i]) * (1-fay[i]) * (Zatom[i]**zed) for i in range(len(fax))])\n #V1 = numpy.array([fax[i] * fay[i] * scalefactor for i in range(len(fax))])\n #V2 = numpy.array([(1-fax[i]) * fay[i] * scalefactor for i in range(len(fax))])\n #V3 = numpy.array([fax[i] * (1-fay[i]) * scalefactor for i in range(len(fax))])\n #V4 = numpy.array([(1-fax[i]) * (1-fay[i]) * scalefactor for i in range(len(fax))])\n\n for j in range(amax):\n V[iax[j],iay[j]] += V1[j]\n V[ibx[j],iay[j]] += V2[j]\n V[iax[j],iby[j]] += V3[j]\n V[ibx[j],iby[j]] += V4[j]\n rev_trans = [-1.0*i for i in trans]\n atms.translate(rev_trans)\n return V","def box_collision_info(self):\r\n position = np.zeros((self.Npart,3)) # antall part, dim, iterasjoner\r\n position[:,:] = np.random.uniform(0,1e-6, size = (self.Npart,3))\r\n velocity = np.zeros((self.Npart,3))\r\n velocity[:,:] = np.random.normal(0,self.sigma,size = (self.Npart,3))\r\n\r\n part_collided = 0\r\n part_escaped = 0\r\n momentum = 0\r\n\r\n print 'engine started'\r\n for i in xrange(1,self.n):\r\n #collision\r\n position += velocity*dt\r\n l_hole = position[:,0:2] > self.L/4\r\n h_hole = position[:,0:2] < (3*self.L)/4\r\n pos_xy = np.logical_and(l_hole, h_hole)\r\n pos_xy = np.logical_and(pos_xy[:,0], pos_xy[:,1])\r\n pos_z = position[:,2] < 0\r\n esc_part = np.logical_and(pos_z, pos_xy)\r\n\r\n #velocity[esc_part] = velocity[esc_part]\r\n part_escaped += np.sum(esc_part)\r\n\r\n for j in xrange(0,3):\r\n impact_wall_pos = np.logical_and(position[:,j] > 0,\r\n position[:,j] < self.L)\r\n velocity[np.logical_not(impact_wall_pos),j] = -velocity[\r\n np.logical_not(impact_wall_pos),j]\r\n\r\n\r\n if j == 0:\r\n part_collided += np.sum(np.logical_not(impact_wall_pos),j)\r\n momentum += np.sum(2*self.m*abs(velocity[np.logical_not(\r\n impact_wall_pos),j]))\r\n\r\n\r\n\r\n position[position < 0] = 0\r\n position[position >self.L] = self.L\r\n\r\n particle_collided = part_collided/2\r\n return position, velocity,part_escaped, impact_wall_pos, particle_collided, momentum","def clashTest(self, px, py, pz, rad):\n radSq = rad**2\n # adjust for map not set at origin\n px -= self.unif[0]\n py -= self.unif[1]\n pz -= self.unif[2]\n ht = self.height/255\n halfw = self.width/2.0\n halfd = self.depth/2.0\n dx = self.width/self.ix\n dz = self.depth/self.iy\n\n # work out x and z ranges to check, x0 etc correspond with vertex indices in grid\n x0 = int(math.floor((halfw + px - rad)/dx + 0.5)) - 1\n if x0 < 0: x0 = 0\n x1 = int(math.floor((halfw + px + rad)/dx + 0.5)) + 1\n if x1 > self.ix-1: x1 = self.ix-1\n z0 = int(math.floor((halfd + pz - rad)/dz + 0.5)) - 1\n if z0 < 0: z0 = 0\n z1 = int(math.floor((halfd + pz + rad)/dz + 0.5)) + 1\n if z1 > self.iy-1: z1 = self.iy-1\n\n # go through grid around px, pz\n minDist, minLoc = 1000000, (0, 0)\n for i in xrange(x0+1, x1):\n for j in xrange(z0+1, z1):\n # use the locations stored in the one dimensional vertices matrix\n #generated in __init__. 3 values for each location\n p = j*self.ix + i # pointer to the start of xyz for i,j in the vertices array\n p1 = j*self.ix + i - 1 # pointer to the start of xyz for i-1,j\n p2 = (j-1)*self.ix + i # pointer to the start of xyz for i, j-1\n vertp = self.buf[0].vertices[p]\n normp = self.buf[0].normals[p]\n # work out distance squared from this vertex to the point\n distSq = (px - vertp[0])**2 + (py - vertp[1])**2 + (pz - vertp[2])**2\n if distSq < minDist: # this vertex is nearest so keep a record\n minDist = distSq\n minLoc = (i, j)\n #now find the distance between the point and the plane perpendicular\n #to the normal at this vertex\n pDist = dot([px - vertp[0], py - vertp[1], pz - vertp[2]],\n [-normp[0], -normp[1], -normp[2]])\n #and the position where the normal from point crosses the plane\n xIsect = px - normp[0]*pDist\n zIsect = pz - normp[2]*pDist\n\n #if the intersection point is in this rectangle then the x,z values\n #will lie between edges\n if xIsect > self.buf[0].vertices[p1][0] and \\\n xIsect < self.buf[0].vertices[p][0] and \\\n zIsect > self.buf[0].vertices[p2][2] and \\\n zIsect < self.buf[0].vertices[p][2]:\n pDistSq = pDist**2\n # finally if the perpendicular distance is less than the nearest so far\n #keep a record\n if pDistSq < minDist:\n minDist = pDistSq\n minLoc = (i,j)\n\n gLevel = self.calcHeight(px, pz) #check it hasn't tunnelled through by going fast\n if gLevel > (py-rad):\n minDist = py - gLevel\n minLoc = (int((x0+x1)/2), int((z0+z1)/2))\n\n if minDist <= radSq: #i.e. near enough to clash so return normal\n p = minLoc[1]*self.ix + minLoc[0]\n normp = self.buf[0].normals[p]\n if minDist < 0:\n jump = rad - minDist\n else:\n jump = 0\n return(True, normp[0], normp[1], normp[2], jump)\n else:\n return (False, 0, 0, 0, 0)","def clashTest(self, px, py, pz, rad):\r\n radSq = rad**2\r\n # adjust for map not set at origin\r\n px -= self.unif[0]\r\n py -= self.unif[1]\r\n pz -= self.unif[2]\r\n ht = self.height/255\r\n halfw = self.width/2.0\r\n halfd = self.depth/2.0\r\n dx = self.width/self.ix\r\n dz = self.depth/self.iy\r\n\r\n # work out x and z ranges to check, x0 etc correspond with vertex indices in grid\r\n x0 = int(math.floor((halfw + px - rad)/dx + 0.5)) - 1\r\n if x0 < 0: x0 = 0\r\n x1 = int(math.floor((halfw + px + rad)/dx + 0.5)) + 1\r\n if x1 > self.ix-1: x1 = self.ix-1\r\n z0 = int(math.floor((halfd + pz - rad)/dz + 0.5)) - 1\r\n if z0 < 0: z0 = 0\r\n z1 = int(math.floor((halfd + pz + rad)/dz + 0.5)) + 1\r\n if z1 > self.iy-1: z1 = self.iy-1\r\n\r\n # go through grid around px, pz\r\n minDist, minLoc = 1000000, (0, 0)\r\n for i in xrange(x0+1, x1):\r\n for j in xrange(z0+1, z1):\r\n # use the locations stored in the one dimensional vertices matrix\r\n #generated in __init__. 3 values for each location\r\n p = j*self.ix + i # pointer to the start of xyz for i,j in the vertices array\r\n p1 = j*self.ix + i - 1 # pointer to the start of xyz for i-1,j\r\n p2 = (j-1)*self.ix + i # pointer to the start of xyz for i, j-1\r\n vertp = self.buf[0].vertices[p]\r\n normp = self.buf[0].normals[p]\r\n # work out distance squared from this vertex to the point\r\n distSq = (px - vertp[0])**2 + (py - vertp[1])**2 + (pz - vertp[2])**2\r\n if distSq < minDist: # this vertex is nearest so keep a record\r\n minDist = distSq\r\n minLoc = (i, j)\r\n #now find the distance between the point and the plane perpendicular\r\n #to the normal at this vertex\r\n pDist = dot([px - vertp[0], py - vertp[1], pz - vertp[2]],\r\n [-normp[0], -normp[1], -normp[2]])\r\n #and the position where the normal from point crosses the plane\r\n xIsect = px - normp[0]*pDist\r\n zIsect = pz - normp[2]*pDist\r\n\r\n #if the intersection point is in this rectangle then the x,z values\r\n #will lie between edges\r\n if xIsect > self.buf[0].vertices[p1][0] and \\\r\n xIsect < self.buf[0].vertices[p][0] and \\\r\n zIsect > self.buf[0].vertices[p2][2] and \\\r\n zIsect < self.buf[0].vertices[p][2]:\r\n pDistSq = pDist**2\r\n # finally if the perpendicular distance is less than the nearest so far\r\n #keep a record\r\n if pDistSq < minDist:\r\n minDist = pDistSq\r\n minLoc = (i,j)\r\n\r\n gLevel = self.calcHeight(px, pz) #check it hasn't tunnelled through by going fast\r\n if gLevel > (py-rad):\r\n minDist = py - gLevel\r\n minLoc = (int((x0+x1)/2), int((z0+z1)/2))\r\n\r\n if minDist <= radSq: #i.e. near enough to clash so return normal\r\n p = minLoc[1]*self.ix + minLoc[0]\r\n normp = self.buf[0].normals[p]\r\n if minDist < 0:\r\n jump = rad - minDist\r\n else:\r\n jump = 0\r\n return(True, normp[0], normp[1], normp[2], jump)\r\n else:\r\n return (False, 0, 0, 0, 0)","def compute_magnetic_field(self, coords, params=None, basis=\"rpz\"):\n assert basis.lower() in [\"rpz\", \"xyz\"]\n if isinstance(coords, Grid):\n coords = coords.nodes\n coords = jnp.atleast_2d(coords)\n if basis == \"xyz\":\n coords = xyz2rpz(coords)\n bp = self._B0 * self._R0 / coords[:, 0]\n brz = jnp.zeros_like(bp)\n B = jnp.array([brz, bp, brz]).T\n if basis == \"xyz\":\n B = rpz2xyz_vec(B, phi=coords[:, 1])\n\n return B","def magnetization(h):\n if h.has_eh: raise\n if h.has_spin: \n mx = extract.mx(h.intra)\n my = extract.my(h.intra)\n mz = extract.mz(h.intra)\n else: raise\n np.savetxt(\"MAGNETIZATION_X.OUT\",np.matrix([h.geometry.x,h.geometry.y,mx]).T)\n np.savetxt(\"MAGNETIZATION_Y.OUT\",np.matrix([h.geometry.x,h.geometry.y,my]).T)\n np.savetxt(\"MAGNETIZATION_Z.OUT\",np.matrix([h.geometry.x,h.geometry.y,mz]).T)","def compute_magnetic_field(self, coords, params=None, basis=\"rpz\"):\n assert basis.lower() in [\"rpz\", \"xyz\"]\n if isinstance(coords, Grid):\n coords = coords.nodes\n coords = jnp.atleast_2d(coords)\n if basis == \"xyz\":\n coords = xyz2rpz(coords)\n\n R, phi, Z = coords.T\n r = jnp.sqrt((R - self._R0) ** 2 + Z**2)\n theta = jnp.arctan2(Z, R - self._R0)\n br = -r * jnp.sin(theta)\n bp = jnp.zeros_like(br)\n bz = r * jnp.cos(theta)\n bmag = self._B0 * self._iota / self._R0\n B = bmag * jnp.array([br, bp, bz]).T\n if basis == \"xyz\":\n B = rpz2xyz_vec(B, phi=coords[:, 1])\n\n return B","def compute_magnetic_field(self, coords, params=None, basis=\"rpz\"):\n assert basis.lower() in [\"rpz\", \"xyz\"]\n if isinstance(coords, Grid):\n coords = coords.nodes\n coords = jnp.atleast_2d(coords)\n if basis == \"xyz\":\n coords = xyz2rpz(coords)\n Rq, phiq, Zq = coords.T\n if self._axisym:\n BRq = interp2d(\n Rq,\n Zq,\n self._R,\n self._Z,\n self._BR[:, 0, :],\n self._method,\n (0, 0),\n self._extrap,\n (None, None),\n **self._derivs[\"BR\"],\n )\n Bphiq = interp2d(\n Rq,\n Zq,\n self._R,\n self._Z,\n self._Bphi[:, 0, :],\n self._method,\n (0, 0),\n self._extrap,\n (None, None),\n **self._derivs[\"Bphi\"],\n )\n BZq = interp2d(\n Rq,\n Zq,\n self._R,\n self._Z,\n self._BZ[:, 0, :],\n self._method,\n (0, 0),\n self._extrap,\n (None, None),\n **self._derivs[\"BZ\"],\n )\n\n else:\n BRq = interp3d(\n Rq,\n phiq,\n Zq,\n self._R,\n self._phi,\n self._Z,\n self._BR,\n self._method,\n (0, 0, 0),\n self._extrap,\n (None, self._period, None),\n **self._derivs[\"BR\"],\n )\n Bphiq = interp3d(\n Rq,\n phiq,\n Zq,\n self._R,\n self._phi,\n self._Z,\n self._Bphi,\n self._method,\n (0, 0, 0),\n self._extrap,\n (None, self._period, None),\n **self._derivs[\"Bphi\"],\n )\n BZq = interp3d(\n Rq,\n phiq,\n Zq,\n self._R,\n self._phi,\n self._Z,\n self._BZ,\n self._method,\n (0, 0, 0),\n self._extrap,\n (None, self._period, None),\n **self._derivs[\"BZ\"],\n )\n B = jnp.array([BRq, Bphiq, BZq]).T\n if basis == \"xyz\":\n B = rpz2xyz_vec(B, phi=coords[:, 1])\n return B","def compute_magnetic_field(self, coords, params=None, basis=\"rpz\"):\n assert basis.lower() in [\"rpz\", \"xyz\"]\n if isinstance(coords, Grid):\n coords = coords.nodes\n coords = jnp.atleast_2d(coords)\n if basis == \"xyz\":\n coords = xyz2rpz(coords)\n Rq, phiq, Zq = coords.T\n\n if (params is None) or (len(params) == 0):\n params = self._params\n r, p, z = coords.T\n funR = lambda x: self._potential(x, p, z, **params)\n funP = lambda x: self._potential(r, x, z, **params)\n funZ = lambda x: self._potential(r, p, x, **params)\n br = Derivative.compute_jvp(funR, 0, (jnp.ones_like(r),), r)\n bp = Derivative.compute_jvp(funP, 0, (jnp.ones_like(p),), p)\n bz = Derivative.compute_jvp(funZ, 0, (jnp.ones_like(z),), z)\n B = jnp.array([br, bp / r, bz]).T\n if basis == \"xyz\":\n B = rpz2xyz_vec(B, phi=coords[:, 1])\n return B","def magnetic_field(self, xyz):\n dxyz = self.vector_distance(xyz)\n r = spatial.repeat_scalar(self.distance(xyz))\n kr = self.wavenumber*r\n ikr = 1j*kr\n\n front_term = self.moment / (4. * np.pi * r**3) * np.exp(-ikr)\n symmetric_term = (\n spatial.repeat_scalar(self.dot_orientation(dxyz)) * dxyz *\n (-kr**2 + 3*ikr + 3) / r**2\n )\n oriented_term = (\n (kr**2 - ikr - 1) *\n np.kron(self.orientation, np.ones((dxyz.shape[0], 1)))\n )\n\n return front_term * (symmetric_term + oriented_term)","def get_data(eh, file_list):\n x_pos = []\n y_pos = []\n x_vel = []\n y_vel = []\n z_vel = []\n unique_x = []\n unique_y = []\n\n # reading data\n for file in file_list:\n with open(file, 'r') as f:\n f.readline() # Ignores first line\n for line in f:\n line = line.strip()\n column = line.split()\n if len(column) == 4:\n if file == file_list[0]:\n # Only takes position data from first file as the same in each file\n x_pos.append(float(column[0]))\n y_pos.append(float(column[1]))\n\n x_vel.append(float(column[2]))\n y_vel.append(float(column[3]))\n z_vel.append(0.0)\n\n if float(column[0]) not in unique_x:\n unique_x.append(float(column[0]))\n if float(column[1]) not in unique_y:\n unique_y.append(float(column[1]))\n else:\n x_vel.append(float(column[2]))\n y_vel.append(float(column[3]))\n z_vel.append(0.0)\n else:\n print \"Error: TXT file is not correct!\"\n\n ux = len(unique_x)\n uy = len(unique_y)\n\n\n # xmid and ymid are used to get xz- and yz-planes. The median value is used. If the number of\n # unique xs and ys is even, then the median value will be one that does not correspond to a\n # measurement. When this is the case, the first value is ignored so that the number of uniques is\n # odd, resulting in a median value that corresponds to a measurement.\n if ux % 2 == 0:\n xmid = np.median(unique_x[1:])\n else:\n xmid = np.median(unique_x)\n\n if uy % 2 == 0:\n ymid = np.median(unique_y[1:])\n else:\n ymid = np.median(unique_y)\n\n if eh == exp_h_list[-1]:\n print \"All data read.\"\n\n\n # checks list lengths to ensure matching and then averages the velocities for all files\n # and then returns an array with position and average velocities\n if len(x_pos) == len(y_pos):\n pos_count = len(x_pos)\n if len(x_vel) == len(y_vel) and len(x_vel) == len(z_vel):\n vel_count = len(x_vel)\n nof = vel_count / pos_count # equals number of files for each height\n ax_vel, ay_vel, az_vel = avg_data_each_h(nof, pos_count, x_vel, y_vel, z_vel)\n\n if make_sg:\n subgrid_array = sub_grid(ux, x_pos, y_pos, eh, ax_vel, ay_vel, az_vel)\n return subgrid_array\n else:\n z_pos = [eh] * len(x_pos)\n return xmid, ymid, zip(x_pos, y_pos, z_pos, ax_vel, ay_vel, az_vel)\n else:\n print \"Error: different number of velocities!\"\n else:\n print \"Error: not all x-positions have a corresponding y-position!\"","def compute_magnetic_field(self, coords, params=None, basis=\"rpz\"):\n assert basis.lower() in [\"rpz\", \"xyz\"]\n if isinstance(coords, Grid):\n coords = coords.nodes\n coords = jnp.atleast_2d(coords)\n if basis == \"xyz\":\n coords = xyz2rpz(coords)\n bz = self._B0 * jnp.ones_like(coords[:, 2])\n brp = jnp.zeros_like(bz)\n B = jnp.array([brp, brp, bz]).T\n if basis == \"xyz\":\n B = rpz2xyz_vec(B, phi=coords[:, 1])\n\n return B","def rotationDetermination(self):\n \n for index, row in enumerate(self.magdata):\n if index > 11 and index < (len(self.magdata) - 12):\n br1 = [row[0] for row in self.magdata[(index-12):(index-2)]]\n bt1 = [row[1] for row in self.magdata[(index-12):(index-2)]]\n bn1 = [row[2] for row in self.magdata[(index-12):(index-2)]]\n b1 = np.matrix((np.mean(br1), np.mean(bt1), np.mean(bn1)))\n\n br2 = [row[0] for row in self.magdata[(index+2):(index+12)]]\n bt2 = [row[1] for row in self.magdata[(index+2):(index+12)]]\n bn2 = [row[2] for row in self.magdata[(index+2):(index+12)]]\n b2 = np.matrix((np.mean(br2), np.mean(bt2), np.mean(bn2)))\n\n theta = np.arccos(np.dot(b1,b2.T)/(np.linalg.norm(b1)*np.linalg.norm(b2)))*180/np.pi\n\n self.detections.rotations.append(theta[0,0])\n self.detections.rotationTimeTags.append(self.timestamps[index])\n \n\n## self.b1 = b1\n## self.b2 = b2\n self.detections.rotationBoundary=[]\n if len(self.detections.rotations) != 0:\n \n for index, theta in enumerate(self.detections.rotations):\n if index > 0:\n if theta > 30 and self.detections.rotations[index-1] < 30:\n self.detections.rotationBoundary.append(self.detections.rotationTimeTags[index])\n if index < len(self.detections.rotations)-1:\n if theta > 30 and self.detections.rotations[index+1] < 30:\n self.detections.rotationBoundary.append(self.detections.rotationTimeTags[index])","def get_things1(kp_3d, kp_2d, des, comp_list, H, map_3d, map_2d, map_des, map_cam, map_view, my_max):\n # Initializing the arrays\n points_3d = []\n points_2d = []\n camera_ind = []\n points_ind = []\n cam_params = []\n\n dst_3d = kp_3d\n dst_2d = kp_2d\n src_3d = map_3d\n src_2d = map_2d\n src_cam = map_cam\n low_bound = []\n up_bound = []\n my_min = 0\n\n # Updating the Camera parameters in map and setting the bounds for the update \n for i in range(my_min,my_max+1):\n cam_param = [map_view[i,0], map_view[i,1], map_view[i,2], map_view[i,3], map_view[i,4], map_view[i,5], f,0,0]\n cam_params.append(cam_param)\n\n low_bound.append(-np.pi)\n low_bound.append(-np.pi)\n low_bound.append(-np.pi)\n low_bound.append(-20)\n low_bound.append(-np.inf)\n low_bound.append(-20)\n low_bound.append(f-1)\n low_bound.append(-1)\n low_bound.append(-1)\n up_bound.append(np.pi)\n up_bound.append(np.pi)\n up_bound.append(np.pi)\n up_bound.append(20)\n up_bound.append(np.inf)\n up_bound.append(20)\n up_bound.append(f)\n up_bound.append(0)\n up_bound.append(0)\n \n # Updating the Camera parameters for frame and setting the bounds for the update\n r = (R.from_matrix((H[0:3, 0:3]))).as_rotvec()\n t = H[:,3]\n cam_param = [r[0], r[1], r[2], t[0], t[1], t[2], f, 0, 0]\n cam_params.append(cam_param)\n \n low_bound.append(-np.pi)\n low_bound.append(-np.pi)\n low_bound.append(-np.pi)\n low_bound.append(-20)\n low_bound.append(-np.inf)\n low_bound.append(-20)\n low_bound.append(f-1)\n low_bound.append(-1)\n low_bound.append(-1)\n up_bound.append(np.pi)\n up_bound.append(np.pi)\n up_bound.append(np.pi)\n up_bound.append(20)\n up_bound.append(np.inf)\n up_bound.append(20)\n up_bound.append(f)\n up_bound.append(0)\n up_bound.append(0)\n\n new_cam = len(cam_params)-1\n cam_params = np.array(cam_params).reshape(-1,9)\n count = 0\n \n # listing variables to iterate \n l1 = []\n l2 = []\n count = 0\n \n for m in comp_list:\n count+=1\n l1.append(m.queryIdx)\n l2.append(m.trainIdx)\n\n l1 = np.array(l1).reshape(1,-1)\n l2 = np.array(l2).reshape(1,-1)\n l = np.vstack((l1,l2))\n l_fin = l[:,l[1, :].argsort()]\n j = 0\n count = len(points_3d)\n prev = -1\n final_l1 = []\n final_l2 = []\n final_des = []\n\n # Iterating through the list made and making sure no duplicates\n while(j<(len(l_fin[0]))):\n i1 = l_fin[0,j]\n i2 = l_fin[1,j]\n if(i2!=prev):\n # Map points insertion\n \n check = 0\n for ii in range(len(src_2d[i1])):\n m_2d = src_2d[i1][ii]\n check = 1\n ind = int(src_cam[i1][ii])\n points_2d.append([int((m_2d[0]%(2*cx))-cx), int((m_2d[1]%(2*cy))-cy),0])\n\n points_ind.append(count)\n camera_ind.append(ind)\n final_l1.append(i1)\n final_l2.append(0)\n \n # Taking Mean Desciptor if needed un comment 2 lines below\n # x = ((map_des[i1]*len(src_2d[i1]))+des[i2])/(len(src_2d[i1])+1)\n # map_des[i1] = x\n \n if(check==1):\n # Frame points insersion\n points_2d.append([int((dst_2d[i2,0])-cx), int((dst_2d[i2,1])-cy), 0])\n points_ind.append(count)\n camera_ind.append(new_cam)\n final_l1.append(i2)\n final_l2.append(1)\n wld_pt = src_3d[i1]\n points_3d.append([wld_pt[0], wld_pt[1], wld_pt[2]])\n prev = i2\n count = len(points_3d)\n low_bound.append(-20)\n low_bound.append(-np.inf)\n low_bound.append(-20)\n up_bound.append(20)\n up_bound.append(np.inf)\n up_bound.append(20)\n src_2d[i1].append([int((dst_2d[i2,0])), int((dst_2d[i2,1]))])\n j+=1\n \n # Final Output\n cam_params = np.array(cam_params).reshape(-1,9)\n points_3d = np.array(points_3d)\n points_2d = np.array(points_2d)\n camera_ind = np.array(camera_ind).reshape(len(camera_ind))\n points_ind = np.array(points_ind).reshape(len(points_ind))\n final_l1 = np.array(final_l1)\n final_l2 = np.array(final_l2)\n return cam_params, points_3d, points_2d, camera_ind, points_ind, final_l1, final_l2, low_bound, up_bound, map_des, src_2d","def get_motion(frame1k, frame2k, frame_count):\n frame1 = frame1k.copy()\n frame2 = frame2k.copy()\n\n global limb_coords, init_coords, num_blocks\n cv2.imwrite(\"thisImageAnalyse.png\", frame2)\n block_size = 3\n block_rad = int(block_size/2)\n\n def get_SSD():\n \"\"\" applies SSD formula to search area\n :return SSD value\"\"\"\n dist = 0\n # traversal of pixels in potential Bi+1 block\n # compare corresponding pixel positions with source block in f1 and neighbour block in f2\n y1 = center_y1 - block_rad # start pos.\n for y2 in range(center_y2 - block_rad, (center_y2 - block_rad + block_size)):\n x1 = center_x1 - block_rad # start pos\n for x2 in range(center_x2 - block_rad, (center_x2 - block_rad + block_size)):\n try:\n # displacement formula for RGB channels of each pixel in block\n dist = dist + (frame1[y1][x1][0] - frame2[y2][x2][0])**2 + (frame1[y1][x1][1] - frame2[y2][x2][1])**2 + (frame1[y1][x1][2] - frame2[y2][x2][2])**2\n except RuntimeWarning:\n pass\n x1 += 1\n y1 += 1\n return math.sqrt(dist)\n\n # for each body part\n b = 0\n while b < 5:\n avg_x = 0.0\n avg_y = 0.0\n new_x = 0.0\n new_y = 0.0\n a = 0\n # for each block on body part (9 total)\n while a < num_blocks:\n found = False\n search_rad = 5\n while found is False:\n center_y1 = int(init_coords[b][a][0])\n center_x1 = int(init_coords[b][a][1])\n min_SSD = 999999\n # for pythagoras to ensure closest block gets picked when equality occurs of SSD value\n min_d = 999999\n # this finds the center of the block to compare\n for factor_y in range(-search_rad, search_rad + 1):\n center_y2 = center_y1 + block_size*factor_y\n y_dist = center_y1 - abs(center_y2)\n for factor_x in range(-search_rad, search_rad + 1):\n center_x2 = center_x1 + block_size*factor_x\n x_dist = center_x1 - abs(center_x2)\n # pythagoras\n d = math.sqrt((y_dist**2 + x_dist**2))\n if d < min_d:\n min_d = d\n\n SSD = get_SSD()\n if frame2[center_y2][center_x2][1] != 0 and frame2[center_y2][center_x2][2] != 0:\n found = True\n if SSD < min_SSD:\n min_SSD = SSD\n new_y = center_y2\n new_x = center_x2\n elif SSD == min_SSD and d < min_d:\n new_y = center_y2\n new_x = center_x2\n if found is False:\n # if no block is found repeat the search, increasing the search size by 1\n search_rad += 1\n # draw extracted vectors\n cv2.arrowedLine(frame1k, (int(center_x1), int(center_y1)), (int(new_x), int(new_y)), (150, 200, 30), 1, 4, 0, 0.3)\n avg_x += new_x\n avg_y += new_y\n init_coords[b][a][0] = new_y\n init_coords[b][a][1] = new_x\n a += 1\n cv2.imwrite('monkeyFrames/contrast_enhanced%d.png' % frame_count, frame1k)\n limb_coords[b][frame_count][0] = int(avg_y/num_blocks)\n limb_coords[b][frame_count][1] = int(avg_x/num_blocks)\n b += 1","def update_position(self, event):\n\n # Create a copy of the most recent stored twist data to perform calculations\n with self.lock:\n velocity_data = copy.deepcopy(self.twist)\n\n # Time elapsed since last update position call\n if hasattr(event, 'last_real'):\n if event.last_real is None:\n time = rospy.Duration(0.05)\n else:\n time = event.current_real - event.last_real\n \n time = time.to_sec()\n\n # Calculate angle turned in the given time using omega = theta/time\n angle = velocity_data.angular.z*time\n\n # Calculate distance travelled in the given time using linear velocity = arc distance/time\n distance = velocity_data.linear.x*time\n\n # Calculate yaw of the robot\n self.vehicle_yaw += angle\n\n # Calculate vehicle x, y, z position coordinates\n # TODO recalculate the position based on traveling in a circular arc.\n self.pose.position.x += (distance)*cos(self.vehicle_yaw)\n self.pose.position.y += (distance)*sin(self.vehicle_yaw)\n\n # Calculate z position using linear interpolation and create cloud array\n \n # 1. Create ranges to be used in interpolation function\n terrain_points_x = np.arange(0, self.gaussian_array.shape[1]*self.resolution, self.resolution)\n terrain_points_y = np.arange(0, self.gaussian_array.shape[0]*self.resolution, self.resolution)\n\n # 2. Create array of points to be converted to point cloud for vizualization\n terrain_mesh_x, terrain_mesh_y = np.meshgrid(terrain_points_x, terrain_points_y)\n terrain_x = terrain_mesh_x.ravel()\n terrain_y = terrain_mesh_y.ravel()\n terrain_z = self.gaussian_array.ravel()\n terrain_grid_points = np.stack((terrain_x, terrain_y, terrain_z), axis=1)\n\n # 3. Create interpolation function based on the ranges and gaussian data\n interp_func = RectBivariateSpline(terrain_points_y, terrain_points_x, self.gaussian_array)\n\n # 4. Find z value for x and y coordinate of vehicle using interpolation function\n # TODO compute z height based on footprint\n self.pose.position.z = interp_func(self.pose.position.y, self.pose.position.x)\n\n # Convert Euler Angles to Quarternion\n V_rotation = tf.transformations.quaternion_from_euler(0.0, 0.0, self.vehicle_yaw)\n\n # Broadcast vehicle frame which is a child of the world frame\n br = tf.TransformBroadcaster()\n br.sendTransform((self.pose.position.x, self.pose.position.y, self.pose.position.z), \n V_rotation, rospy.Time.now(),\"vehicle_frame\", \"map\")\n\n # Construct the homogenous transformation matrix for map to vehicle frame\n V_translation = [self.pose.position.x, self.pose.position.y, self.pose.position.z]\n map_T_V = tf.transformations.quaternion_matrix(V_rotation) \n map_T_V[:3,3] = np.array(V_translation)\n\n # Create footprint of vehicle\n V_footprint_range_x = np.linspace((-self.vehicle_length/2), (self.vehicle_length/2), 30)\n V_footprint_range_y = np.linspace((-self.vehicle_width/2), (self.vehicle_width/2), 15)\n V_footprint_mesh_x, V_footprint_mesh_y = np.meshgrid(V_footprint_range_x, V_footprint_range_y)\n V_footprint_x = V_footprint_mesh_x.ravel()\n V_footprint_y = V_footprint_mesh_y.ravel()\n\n # For every point in the vehicle footprint, calculate the position wrt to the vehicle's frame\n # and its interpolated z value. Add this point to a list of points for visualization.\n # TODO Flatten into a single matrix multiply to remove for loop\n V_viz_points = []\n for i in range(V_footprint_x.shape[0]):\n p = Point()\n V_footprint_point = np.array([[V_footprint_x[i]],[V_footprint_y[i]], [0.0], [1.0]])\n V_footprint_point = np.matmul(map_T_V, V_footprint_point)\n V_footprint_point[2, 0] = interp_func(V_footprint_point[1, 0], V_footprint_point[0, 0])\n p.x = V_footprint_point[0, 0]\n p.y = V_footprint_point[1, 0]\n p.z = V_footprint_point[2, 0]\n V_viz_points.append(p)\n\n #####################################################################################\n # Create a copy of the most recent stored JointState data to perform calculations\n with self.joint_lock:\n joint_data = copy.deepcopy(self.joint)\n\n # If the data is empty on first run, fill with 0.0\n if not joint_data.velocity:\n joint_data.velocity = [0.0,0.0]\n \n # Calculate angle based on velocity data and time\n angle = joint_data.velocity[0]*time\n angle2 = joint_data.velocity[1]*time\n\n self.joint1_pitch += angle\n self.joint2_pitch += angle2\n\n # Transformations from vehicle frame to Joint1 and Joint2\n \n # Static rotation about z-axis \n static_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 3.14159)\n translation = [0.0, 0.0, 0.0]\n V_T_SRz = tf.transformations.quaternion_matrix(static_rot)\n V_T_SRz[:3,3] = np.array(translation)\n\n # Dynamic rotation about the y-axis of Joint 1\n rot_SRz_T_J1 = [[cos(self.joint1_pitch), 0.0, sin(self.joint1_pitch)],\n [0.0, 1.0, 0.0],\n [-sin(self.joint1_pitch), 0.0, cos(self.joint1_pitch)]]\n\n trans_SRz_T_J1 = [0.0, 0.0, 0.0, 1.0]\n\n SRz_T_J1 = np.zeros((4,4))\n SRz_T_J1[:3,:3] = rot_SRz_T_J1\n SRz_T_J1[:4,3] = trans_SRz_T_J1\n\n # Translation based on length of Joint 1 arm \n no_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 0.0)\n translation = [self.joint1_length, 0.0, 0.0]\n J1_T_STx = tf.transformations.quaternion_matrix(no_rot)\n J1_T_STx[:3,3] = np.array(translation)\n\n # Dynamic rotation about y-axis of Joint 2\n dynamic_rot2 = tf.transformations.quaternion_from_euler(0.0, self.joint2_pitch, 0.0)\n translation = [0.0, 0.0, 0.0]\n STx_T_J2 = tf.transformations.quaternion_matrix(dynamic_rot2)\n STx_T_J2[:3,3] = np.array(translation)\n\n # matrix multiplication to form the homogenous matrices\n V_T_J1 = np.matmul(V_T_SRz, SRz_T_J1)\n V_T_STx = np.matmul(V_T_J1, J1_T_STx)\n V_T_J2 = np.matmul(V_T_STx, STx_T_J2)\n\n frame_J1 = tf_conversions.fromMatrix(V_T_J1)\n frame_J2 = tf_conversions.fromMatrix(V_T_J2)\n\n # The ripper tip is a point in the J2's frame, this is based on the length of the ripper\n ripper_tip_point_J2 = [self.ripper_length, 0.0, 0.0, 1.0]\n map_T_J2 = np.matmul(map_T_V, V_T_J2)\n ripper_tip_pt_map = np.matmul(map_T_J2, ripper_tip_point_J2)\n ripper_tip_point_viz = Point()\n ripper_tip_point_viz.x = ripper_tip_pt_map[0]\n ripper_tip_point_viz.y = ripper_tip_pt_map[1]\n ripper_tip_point_viz.z = ripper_tip_pt_map[2]\n V_viz_points.append(ripper_tip_point_viz)\n\n # use the ripper's position as an index value to access the gaussian array\n ripper_tip_cell_index_x = int(ripper_tip_pt_map[1]/self.resolution)\n ripper_tip_cell_index_y = int(ripper_tip_pt_map[0]/self.resolution)\n\n # Create a range of index values surrounding index_x and y\n nearby_index_cells_range_x = np.arange((ripper_tip_cell_index_x-1),(ripper_tip_cell_index_x+2), 1)\n nearby_index_cells_range_y = np.arange((ripper_tip_cell_index_y-1),(ripper_tip_cell_index_y+2), 1)\n nearby_index_cells_mesh_x, nearby_index_cells_mesh_y = np.meshgrid(nearby_index_cells_range_x,nearby_index_cells_range_y)\n nearby_index_cells_x = nearby_index_cells_mesh_x.ravel()\n nearby_index_cells_y = nearby_index_cells_mesh_y.ravel()\n\n # First check if the index is within the gaussian array, if it is, then check if the tip of\n # the ripper is beneath the soil, if it is, then remove the soil above the tip and disperse\n # it to the surrounding cells, provided those cells are also within the gaussian array\n # TODO Remove use of for loops and excess if statements\n\n if (0 <= ripper_tip_cell_index_x <= (self.gaussian_array.shape[0]-1)) and (0 <= ripper_tip_cell_index_y <= (self.gaussian_array.shape[1]-1)):\n if (self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] > ripper_tip_pt_map[2]):\n diff = self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] - ripper_tip_pt_map[2]\n for i in range(nearby_index_cells_x.shape[0]):\n if (0 <= nearby_index_cells_x[i] <= (self.gaussian_array.shape[0]-1)) and (0 <= nearby_index_cells_y[i] <= (self.gaussian_array.shape[1]-1)):\n self.gaussian_array[nearby_index_cells_x[i]][nearby_index_cells_y[i]] += diff/8\n self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] = ripper_tip_pt_map[2]\n \n\n # Publish all messages\n self.publish_messages(V_translation, V_rotation, terrain_grid_points, V_viz_points, frame_J1, frame_J2)","def cozmoBehavior(robot: cozmo.robot.Robot):\r\n \r\n global grid, stopevent\r\n\r\n foundGoal = False\r\n foudnCenter = False\r\n setPath = False\r\n seen_cubes = []\r\n goToCenter = False\r\n start_ori = grid.getStart()\r\n\r\n while not stopevent.is_set():\r\n if foundGoal == False:\r\n if robot.pose.rotation.angle_z.degrees <= 90:\r\n \r\n cube = None\r\n\r\n try:\r\n cube = robot.world.wait_for_observed_light_cube(timeout=2)\r\n\r\n print(\"Found cube: %s\" % cube)\r\n \r\n if cube not in seen_cubes:\r\n seen_cubes.append(cube)\r\n\r\n pos = cube.pose.position\r\n x, y, z = pos.x, pos.y, pos.z\r\n print()\r\n obs1 = int(x/grid.scale + start_ori[0] + 0.5), int(y/grid.scale + start_ori[1] + 0.5)\r\n add_obs = []\r\n for i in range(-1, 2, 1):\r\n for j in range(-1, 2, 1):\r\n ob = obs1[0] + i, obs1[1] + j\r\n add_obs.append(ob)\r\n grid.addObstacles(add_obs);\r\n\r\n if cube.object_id == robot.world.light_cubes[cozmo.objects.LightCube1Id].object_id:\r\n\r\n foundGoal = True\r\n \r\n cube_angle = cube.pose.rotation.angle_z.degrees\r\n a, b = 0, 0\r\n if cube_angle > -22.5 and cube_angle < 22.5:\r\n a, b = -1, 0\r\n if cube_angle >= 22.5 and cube_angle < 67.5:\r\n a, b = -1, -1\r\n if cube_angle >= 67.5 and cube_angle < 112.5:\r\n a, b = 0, -1\r\n if cube_angle >= 112.5 and cube_angle < 157.5:\r\n a, b = 1, -1\r\n if cube_angle >= 157.5 or cube_angle <= -157.5:\r\n a, b = 1, 0\r\n if cube_angle > -67.5 and cube_angle <= -22.5:\r\n a, b = -1, 1\r\n if cube_angle > -112.5 and cube_angle <= -67.5:\r\n a, b = 0, 1\r\n if cube_angle > -157.5 and cube_angle <= -112.5:\r\n a, b = 1, 1\r\n\r\n goal = obs1[0] + a * 2, obs1[1] + b * 2\r\n grid.clearGoals()\r\n grid.addGoal(goal)\r\n\r\n except asyncio.TimeoutError:\r\n print(\"Didn't find a cube\")\r\n\r\n robot.turn_in_place(degrees(30)).wait_for_completed()\r\n else:\r\n robot.turn_in_place(degrees(-90)).wait_for_completed()\r\n if not foundGoal:\r\n goal = int(grid.width/2), int(grid.height/2)\r\n grid.clearGoals()\r\n grid.addGoal(goal)\r\n foundGoal = True\r\n foundCenter = True\r\n else:\r\n \r\n robot_pose = robot.pose\r\n # print(robot_pose)\r\n rx, ry = robot_pose.position.x, robot_pose.position.y\r\n cx = int(rx/grid.scale + start_ori[0] + 0.5)\r\n cy = int(ry/grid.scale + start_ori[1] + 0.5)\r\n # update start\r\n grid.clearStart()\r\n grid.setStart((cx, cy))\r\n\r\n astar(grid, heuristic)\r\n path = grid.getPath()\r\n print(path)\r\n prev = path[0]\r\n i = 1\r\n while i < len(path):\r\n p = path[i]\r\n diff = p[0] - prev[0], p[1] - prev[1]\r\n\r\n try:\r\n cube = robot.world.wait_for_observed_light_cube(timeout=1)\r\n\r\n if cube:\r\n if cube not in seen_cubes:\r\n # update map\r\n seen_cubes.append(cube)\r\n pos = cube.pose.position\r\n x, y, z = pos.x, pos.y, pos.z\r\n print()\r\n obs1 = int(x/grid.scale + start_ori[0] + 0.5), int(y/grid.scale + start_ori[1] + 0.5)\r\n add_obs = []\r\n for i in range(-1, 2, 1):\r\n for j in range(-1, 2, 1):\r\n ob = obs1[0] + i, obs1[1] + j\r\n add_obs.append(ob)\r\n grid.addObstacles(add_obs)\r\n\r\n if cube.object_id == robot.world.light_cubes[cozmo.objects.LightCube1Id].object_id:\r\n foundGoal = True\r\n foundCenter = False\r\n cube_angle = cube.pose.rotation.angle_z.degrees\r\n # print(\"cube angle is: \", cube_angle)\r\n a, b = 0, 0\r\n if cube_angle > -22.5 and cube_angle < 22.5:\r\n a, b = -1, 0\r\n if cube_angle >= 22.5 and cube_angle < 67.5:\r\n a, b = -1, -1\r\n if cube_angle >= 67.5 and cube_angle < 112.5:\r\n a, b = 0, -1\r\n if cube_angle >= 112.5 and cube_angle < 157.5:\r\n a, b = 1, -1\r\n if cube_angle >= 157.5 or cube_angle <= -157.5:\r\n a, b = 1, 0\r\n if cube_angle > -67.5 and cube_angle <= -22.5:\r\n a, b = -1, 1\r\n if cube_angle > -112.5 and cube_angle <= -67.5:\r\n a, b = 0, 1\r\n if cube_angle > -157.5 and cube_angle <= -112.5:\r\n a, b = 1, 1\r\n\r\n goal = obs1[0] + a * 2, obs1[1] + b * 2\r\n # print(goal)\r\n grid.clearGoals()\r\n grid.addGoal(goal)\r\n # recalculate path\r\n grid.clearStart()\r\n grid.setStart(p)\r\n grid.clearPath()\r\n grid.clearVisited()\r\n astar(grid, heuristic)\r\n path = grid.getPath()\r\n print(\"new path is: \", path)\r\n i = 0\r\n # update the path\r\n except:\r\n print(\"Ball not in vision\")\r\n\r\n\r\n\r\n # Needs to verify\r\n curr_angle = robot.pose.rotation.angle_z\r\n angle = getAngle(diff)\r\n angle_to_turn = angle - curr_angle.degrees\r\n robot.turn_in_place(degrees(angle_to_turn)).wait_for_completed()\r\n\r\n d = math.sqrt(math.pow(diff[0], 2) + math.pow(diff[1], 2))\r\n robot.drive_straight(distance_mm(d*grid.scale), speed_mmps(40)).wait_for_completed()\r\n\r\n # Everytime we move, check to see if there's an obstacle in our vision\r\n\r\n prev = p\r\n i += 1\r\n\r\n \r\n if foundCenter == True: #not in the goal yet\r\n foundGoal = False\r\n foundCenter = False\r\n else:\r\n curr_angle = robot.pose.rotation.angle_z\r\n angle = cube_angle\r\n angle_to_turn = angle - curr_angle.degrees\r\n robot.turn_in_place(degrees(angle_to_turn)).wait_for_completed()\r\n break # Your code here\r","def detector(centre_x, centre_y, height_z, radius, distance):\r\n z = np.linspace(0, height_z, 50)\r\n z = [i+distance for i in z]\r\n \r\n theta = np.linspace(0, 2*np.pi, 50)\r\n theta_grid, z_grid=np.meshgrid(theta, z)\r\n \r\n x_grid = radius*np.cos(theta_grid) + centre_x\r\n y_grid = radius*np.sin(theta_grid) + centre_y\r\n return x_grid, y_grid, z_grid","def galaxy_positions():\n hdulist1 = pf.open(source+'/kids_data/KiDS_DR3.1_G9_ugri_shear.fits')\n '''\n hdulist2 = pf.open('../kids_data/KiDS_DR3.1_G12_ugri_shear.fits')\n hdulist3 = pf.open('../kids_data/KiDS_DR3.1_G15_ugri_shear.fits')\n hdulist4 = pf.open('../kids_data/KiDS_DR3.1_G23_ugri_shear.fits')\n hdulist5 = pf.open('../kids_data/KiDS_DR3.1_GS_ugri_shear.fits')\n '''\n ra = hdulist1[1].data['RAJ2000'][:sample]\n dec = hdulist1[1].data['DECJ2000'][:sample]\n global maxra\n maxra = max(ra)\n global minra\n minra = min(ra)\n global maxdec\n maxdec = max(dec)\n global mindec\n mindec = min(dec)\n global bsize\n bsize = abs(max(maxra, maxdec) - min(mindec, minra))\n coords = np.column_stack([ra, dec])\n global SIZE\n SIZE = len(coords)\n print(maxra, maxdec, minra, mindec, SIZE)\n ctree = cKDTree(coords)\n return ctree","def update_mag(self, mags):\n self.log.mag(mags)\n q = self.quaternion()\n roll, pitch, heading = self.es\n\n mag_inertial = (q * quaternion.Quaternion.from_vec(np.array(mags)) * q.inv()).as_ndarray()[1:]\n mag_inertial[2] = 0\n mag_inertial /= sqrt(mag_inertial[0]**2 + mag_inertial[1]**2)\n mag_body = (q.inv() * quaternion.Quaternion.from_vec(mag_inertial) * q).as_ndarray()[1:]\n\n h = (q.inv() * quaternion.Quaternion.from_vec(np.array([1.0, 0, 0])) * q).as_ndarray()[1:]\n y = np.vstack(mag_body) - np.vstack(h)\n \n H = np.zeros((3, 9))\n ch2 = np.cos(heading/2)\n cr2 = np.cos(roll/2)\n sh2 = np.sin(heading/2)\n sr2 = np.sin(roll/2)\n H[0, 0] = 0\n H[0, 1] = 0\n H[0, 2] = -2.0*ch2*cr2**2*sh2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) - 2.0*ch2*sh2*sr2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2)\n H[1, 0] = 4.0*ch2*cr2*sh2*sr2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2)\n H[1, 1] = 2.0*ch2**2*cr2*sr2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) - 2.0*cr2*sh2**2*sr2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2)\n H[1, 2] = -1.0*ch2**2*cr2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) + 1.0*ch2**2*sr2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) + 1.0*cr2**2*sh2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) - 1.0*sh2**2*sr2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2)\n\n S = H.dot(self.P).dot(H.T) + self.Rmag\n K = self.P.dot(H.T).dot(np.linalg.inv(S))\n x = self.state_vec() + K.dot(y)\n\n self.P = (np.eye(9) - K.dot(H)).dot(self.P)\n self.set_state_vec(x)","def FL_2_mav_sensor(self, data):\n\n (data['velocities/phidot-rad_sec_bf'],\n data['velocities/thetadot-rad_sec_bf'],\n data['velocities/psidot-rad_sec_bf']) = self.convert_body_frame(\n data['attitude/phi-rad'],\n data['attitude/theta-rad'],\n data['velocities/phidot-rad_sec'],\n data['velocities/thetadot-rad_sec'],\n data['velocities/psidot-rad_sec']\n )\n\n #Data treatment\n messagedata = [\n int(data['simulation/sim-time-sec']*self._sec2usec), #time_usec boot time usec int\n data['accelerations/udot-ft_sec2'], #xacc m/s**2 float\n data['accelerations/vdot-ft_sec2'], #yacc m/s**2 float\n data['accelerations/wdot-ft_sec2'], #zacc m/s**2 float\n data['velocities/phidot-rad_sec'], #xgyro rad/s float\n data['velocities/thetadot-rad_sec'], #ygyro rad/s float\n data['velocities/psidot-rad_sec'], #zgyro rad/s float\n data['sensors/magnetometer/X/output'], #xmag Gauss float\n data['sensors/magnetometer/Y/output'], #ymag Gauss float\n data['sensors/magnetometer/Z/output'], #zmag Gauss float\n data['atmosphere/P-psf']*0.478802589, #abs_pr mbar float\n 0.0, #dif_pr mbar float\n data['atmosphere/pressure-altitude'], #pr_alt meter float\n 15.0, #temp C float\n int(8186) #fields_updated (ALL)\n ]\n\n return messagedata","def magnetisation(field):\n norm_field = df.Field(field.mesh, dim=1, value=(field.norm.array != 0))\n volume = df.integral(norm_field * df.dV, direction='xyz')\n return df.integral(field * df.dV / volume, direction='xyz')","def magnetometer(self):\n self._mag[X] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_X_H_M) << 8 | \n self.i2c_bus.read_byte_data(self.addr, OUT_X_L_M), 16)\n self._mag[Y] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_Y_H_M) << 8 | \n self.i2c_bus.read_byte_data(self.addr, OUT_Y_L_M), 16)\n self._mag[Z] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_Z_H_M) << 8 | \n self.i2c_bus.read_byte_data(self.addr, OUT_Z_L_M), 16)\n\n return vector(self._mag)","def read(filename, num_magnets):\n hxy = []\n with open(filename, encoding='latin1', errors='ignore') as f:\n for s in readSections(f):\n pos = float(s[0].split()[-1])\n num = np.array([[float(x) for x in l.split()] for l in s[5:] if l])\n hxy.append({'pos': pos, 'e': num[:, :2], 'hxy': num[:, 2:4],\n 'bxy': num[:, 4:6], 'mxy':num[:, 6:]})\n K = num_magnets\n points = [point(i, np.random.randint(0,K), xy)\n for i, xy in enumerate(hxy[0]['e'])]\n new_means, new_points = fit(points)\n # move values to magnets:\n magnets = [{'e': [p.coord for p in new_points if p.k == k],\n 'pos': [], 'hxy': [], 'bxy': [], 'mxy': []}\n for k in range(K)]\n hkeys = ['hxy', 'bxy', 'mxy']\n for i, h in enumerate(hxy): # all positions\n for mag in magnets:\n mag['pos'].append(h['pos'])\n m = [{k: [] for k in hkeys}\n for kk in range(K)]\n for p in new_points: # all elements\n for k in hkeys:\n m[p.k][k].append(h[k][p.k])\n for mk, magk in zip(m, magnets):\n for k in hkeys:\n magk[k].append(mk[k])\n for mag in magnets:\n for k in ['e'] + hkeys:\n mag[k] = np.array(mag[k])\n mag['havg'] = []\n mag['hmax'] = []\n for hpos in mag['hxy']:\n h = np.abs(np.linalg.norm(hpos, axis=1))\n mag['havg'].append(np.mean(h))\n mag['hmax'].append(np.max(h))\n\n # Note dimension of hkeys is (positions x elements x 2)\n\n return magnets","def tf(xp, yp, zp, spheres, inc, dec, pmag=None):\n if xp.shape != yp.shape != zp.shape:\n raise ValueError(\"Input arrays xp, yp, and zp must have same shape!\")\n tf = numpy.zeros_like(xp)\n # Calculate the 3 components of the unit vector in the direction of the\n # regional field\n fx, fy, fz = utils.dircos(inc, dec)\n if pmag is not None:\n if isinstance(pmag, float) or isinstance(pmag, int):\n pintensity = pmag\n pmx, pmy, pmz = fx, fy, fz\n else:\n pintensity = numpy.linalg.norm(pmag)\n pmx, pmy, pmz = numpy.array(pmag) / pintensity\n for sphere in spheres:\n if sphere is None or ('magnetization' not in sphere.props\n and pmag is None):\n continue\n radius = sphere.radius\n # Get the intensity and unit vector from the magnetization\n if pmag is None:\n mag = sphere.props['magnetization']\n if isinstance(mag, float) or isinstance(mag, int):\n intensity = mag\n mx, my, mz = fx, fy, fz\n else:\n intensity = numpy.linalg.norm(mag)\n mx, my, mz = numpy.array(mag) / intensity\n else:\n intensity = pintensity\n mx, my, mz = pmx, pmy, pmz\n # First thing to do is make the computation point P the origin of the\n # coordinate system\n x = sphere.x - xp\n y = sphere.y - yp\n z = sphere.z - zp\n # Calculate the 3 components of B\n dotprod = mx * x + my * y + mz * z\n r_sqr = x ** 2 + y ** 2 + z ** 2\n r5 = r_sqr ** (2.5)\n moment = intensity * (4. * numpy.pi * (radius ** 3) / 3.)\n bx = moment * (3 * dotprod * x - r_sqr * mx) / r5\n by = moment * (3 * dotprod * y - r_sqr * my) / r5\n bz = moment * (3 * dotprod * z - r_sqr * mz) / r5\n tf += (fx * bx + fy * by + fz * bz)\n tf *= CM * T2NT\n return tf","def ion2_position(self,x,y,z):\n axes_vector = np.array([self.a,self.b,self.c])\n self.ion2 = x*self.a + y*self.b + z*self.c\n self.position['1B'] = np.dot(self.position_map[1],axes_vector) + self.ion2\n self.position['2B'] = np.dot(self.position_map[2],axes_vector) + self.ion2\n self.position['3B'] = np.dot(self.position_map[3],axes_vector) + self.ion2\n self.position['4B'] = np.dot(self.position_map[4],axes_vector) + self.ion2\n self.position['5B'] = np.dot(self.position_map[5],axes_vector) + self.ion2\n self.position['6B'] = np.dot(self.position_map[6],axes_vector) + self.ion2\n self.position['7B'] = np.dot(self.position_map[7],axes_vector) + self.ion2\n self.position['8B'] = np.dot(self.position_map[8],axes_vector) + self.ion2","def magnetic_reynolds(uu, param, grid, aa=list(), bb=list(), jj=list(),\n nghost=3, lmix=True):\n if len(bb) ==0 and len(aa) ==0 and len(jj) ==0:\n print('magnetic_reynolds WARNING: no aa, bb nor jj provided\\n'+\n 'aa or bb must be provided or aa for only hyper resistivity') \n #resistive force\n lres, lhyper3 = False, False\n for iresi in param.iresistivity:\n iresi = str.strip(iresi,'\\n')\n if 'hyper' not in iresi and len(iresi) > 0:\n lres = True\n if 'hyper3' in iresi:\n lhyper3 = True\n fresi = np.zeros_like(uu)\n if lres:\n if lhyper3:\n lhyper3 = lhyper3==lmix\n if len(jj) == 0:\n if len(aa) == 0:\n print('magnetic_reynolds WARNING: calculating jj without aa\\n',\n 'provide aa or jj directly for accurate boundary values')\n jj = curl(bb,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \n coordinate_system=param.coord_system)\n else:\n jj = curl2(aa,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \n coordinate_system=param.coord_system)\n for j in range(0,3):\n jj[j, :nghost,:,:] = jj[j,-2*nghost:-nghost,:,:]\n jj[j,-nghost:,:,:] = jj[j, nghost: 2*nghost,:,:]\n jj[j,:, :nghost,:] = jj[j,:,-2*nghost:-nghost,:]\n jj[j,:,-nghost:,:] = jj[j,:, nghost: 2*nghost,:]\n jj[j,:,:, :nghost] = jj[j,:,:,-2*nghost:-nghost]\n jj[j,:,:,-nghost:] = jj[j,:,:, nghost: 2*nghost]\n fresi = fresi + param.eta*param.mu0*jj\n for iresi in param.iresistivity:\n iresi = str.strip(iresi,'\\n')\n if 'eta-const' not in iresi and 'hyper' not in iresi\\\n and len(iresi) > 0:\n print('magnetic_reynolds WARNING: '+iresi+' not implemented\\n'+\n 'terms may be missing from the standard resistive forces')\n if lhyper3:\n if len(aa) == 0:\n print('magnetic_reynolds WARNING: no aa provided\\n'+\n 'aa must be provided for hyper resistivity')\n return 1\n else:\n del6a = np.zeros_like(aa)\n for j in range(0,3):\n del6a[j] = del6(aa[j],grid.dx,grid.dy,grid.dz)\n del6a[j, :nghost,:,:] = del6a[j,-2*nghost:-nghost,:,:]\n del6a[j,-nghost:,:,:] = del6a[j, nghost: 2*nghost,:,:]\n del6a[j,:, :nghost,:] = del6a[j,:,-2*nghost:-nghost,:]\n del6a[j,:,-nghost:,:] = del6a[j,:, nghost: 2*nghost,:]\n del6a[j,:,:, :nghost] = del6a[j,:,:,-2*nghost:-nghost]\n del6a[j,:,:,-nghost:] = del6a[j,:,:, nghost: 2*nghost]\n #del6 for non-cartesian tba\n #del6a[j] = del6(aa[j],grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y,\n # coordinate_system=param.coord_system)\n #effective at l > 5 grid.dx? \n fresi = fresi + param.eta_hyper3*del6a\n del(del6a)\n fresi2 = np.sqrt(dot2(fresi))\n del(fresi)\n #advective force\n if len(bb) == 0:\n if len(aa) == 0:\n print('magnetic_reynolds WARNING: calculating uu x bb without bb\\n',\n 'provide aa or bb directly to proceed')\n return 1\n else:\n bb = curl(aa,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \n coordinate_system=param.coord_system)\n for j in range(0,3):\n bb[j, :nghost,:,:] = bb[j,-2*nghost:-nghost,:,:]\n bb[j,-nghost:,:,:] = bb[j, nghost: 2*nghost,:,:]\n bb[j,:, :nghost,:] = bb[j,:,-2*nghost:-nghost,:]\n bb[j,:,-nghost:,:] = bb[j,:, nghost: 2*nghost,:]\n bb[j,:,:, :nghost] = bb[j,:,:,-2*nghost:-nghost]\n bb[j,:,:,-nghost:] = bb[j,:,:, nghost: 2*nghost]\n advec = cross(uu,bb)\n advec2 = np.sqrt(dot2(advec))\n del(advec)\n #avoid division by zero\n if fresi2.max() > 0:\n fresi2[np.where(fresi2==0)] = fresi2[np.where(fresi2>0)].min()\n Rm = advec2/fresi2\n #set minimum floor to exclude zero-valued Rm \n if Rm.max() > 0:\n Rm[np.where(Rm==0)] = Rm[np.where(Rm>0)].min()\n else:\n print('Rm undefined')\n else:\n Rm = advec2\n print('Rm undefined')\n return Rm","def CreateLandmask(Fieldset, test = False):\n \n \n \"\"\"\n This first set of lines creates a numpy array with u velocities and a numpy\n array with v velocities. First we get the U and V fields from the dataset. Then\n we compute a time chunk, which is needed because of the dataset. Then we only\n take the first slice of the U and V field (we do not need more for finding the land\n and ocean grids). As last we make an empty array which will be filled with zeros and \n ones.\n \"\"\"\n fU = Fieldset.U\n fV = Fieldset.V\n Fieldset.computeTimeChunk(fU.grid.time[0], 1) \n uvel_mask_c = fU.data[0,:,:] \n vvel_mask_c = fV.data[0,:,:]\n# vvel_mask_c = np.roll(vvel_mask_c, 1, axis = 0)\n landmask = np.zeros((uvel_mask_c.shape[0], uvel_mask_c.shape[1]))\n \n \"\"\"\n The first loop checks the value of the u and v velocitites. Notice that we get the\n values of two adjacent grid, since we're working with a C-grid.\n Visualizations of velocities in the C-grids(see below). So for a grid to be flagged identified\n as a land grid two U velocities and 2 V velocities need to be zero. The first loop makes all\n ocean grids 1 and land grids 0. \n ____ ____ ____ ____\n | V | V | \n | | | \n U T U T U\n | | | \n |____V____|_____V_____| \n \"\"\"\n \n for i in range (len(landmask[:,0])-1):\n for j in range (len(landmask[0,:])-1):\n u1 = uvel_mask_c[i,j]\n\n u2 = uvel_mask_c[i,j+1]\n\n v1 = vvel_mask_c[i,j]\n\n v2 = vvel_mask_c[i+1,j]\n\n if u1 != 0 or u2 != 0 or v1 != 0 or v2 != 0:\n landmask[i,j] = 1\n \n \n \"\"\"\n Change all zero to 1 and rest 0. since we want the land grids to be 1 and ocean\n grids to be 0. \n \"\"\"\n \n landmask = ChangeValues(landmask,0,1) \n \n \"\"\"\n The created landmask needs to be shifted upwards one grid. We will\n use the numpy roll function to do this.\n \"\"\"\n \n if test == True:\n plt.figure()\n plt.imshow(landmask)\n plt.colorbar()\n \n return landmask","def setup_localxyzs(self):\n self.localxyzs = [sp.vscl(1.0/v[2],v) for v in self.uvlclxyzs]\n self.fovsides = list()\n lastxyz = self.localxyzs[-1]\n for xyz in self.localxyzs:\n self.fovsides.append(FOVSIDE(xyz,lastxyz))\n lastxyz = xyz","def find_potential(n=10,nwalks=200):\n \n boundary = np.zeros((n+1, n+1)) # Store boundary potentials\n v = np.zeros((n+1, n+1)) # Store potential for all positions\n \n # Set the boundary conditions\n for i in range(1,n):\n boundary[0,i] = 10\n boundary[n,i] = 10\n boundary[i,0] = 5\n boundary[i,n] = 5\n # Set the the boundary position that maximizes the potential at [3, 5] to 20\n boundary[3,0] = boundary[4,0] = boundary[5,0] = boundary[6,0] = boundary[7,0] = 20\n #boundary[0,3] = boundary[0,4] = boundary[0,5] = boundary[0,6] = boundary[0,7] = 20\n \n v = np.copy(boundary) # Store potential for all positions\n\n # Compute Greens function for each position\n for x in range(1,n):\n for y in range(1,n):\n position = [x, y] # Position to compute Greens function for\n Greens_func = Greens_function_approxRW(n=n, nwalks=nwalks, start_position=position) # The Greens function\n \n # Find potential at current position\n v_pos = potential_from_Greens(boundary, n=n, G=Greens_func, nwalks=nwalks)\n v[position[1], position[0]] = v_pos\n \n # v is now computed for all locations and can be plotted\n fig = plt.figure()\n plt.title('Maximized potential for [3,5]', fontsize = 18)\n im = plt.imshow(v, cmap=None, interpolation='nearest')\n cb = fig.colorbar(im)\n cb.ax.tick_params(labelsize=14)\n plt.show()","def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\n ratio_x = 0\n ratio_y = 0\n ratio_z = 0\n # helm_B = [0,0,0]\n divideby = 0\n for shot in range(shot_range[0], shot_range[1]+1):\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\n ratio_x = ratio_x + x\n ratio_y = ratio_y + y\n ratio_z = ratio_z + z\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\n divideby = divideby + 1 #averaging over the number of shots\n ratio_Bx = ratio_x/divideby\n ratio_By = ratio_y/divideby\n ratio_Bz = ratio_z/divideby\n # helmB = [helm_B]/divideby\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\n # print(\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\n Bx_sqr =ratio_x**2\n By_sqr =ratio_y**2\n Bz_sqr =ratio_z**2\n B = Bx_sqr + By_sqr+ Bz_sqr\n norm_factor = np.sqrt(B)\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\n\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)","def sph(vs, ucs, A, C, x, y, z, rotx=0, roty=0, rotz=0, mode=\"C\"):\n sph = []\n\n if mode == \"A\":\n nA = (A-0.07)/(0.12-0.07)\n nC = (C+0.1)/(0.31+0.1)\n elif mode == \"C\":\n nA = (A-0.07)/(0.12-0.07)\n nC = C/0.307\n elif mode == \"AC\":\n nA = (A-0.07)/(0.12-0.07)\n nC = (C+0.1)/(0.31+0.1)\n else:\n nA = (A-0.07)/(0.12-0.07)\n nC = C/0.307\n\n if (type(nA) is np.float64):\n nA = np.full(len(vs), nA)\n if (type(nC) is np.float64):\n nC = np.full(len(vs), nC)\n\n for v, uc, a, c in zip(vs, ucs, nA, nC):\n if mode == \"A\":\n H0 = a\n L0 = 1/(1+np.exp((-2.8*((a-0.52)*2.4))))\n # R0, G0, B0 = colorsys.hls_to_rgb(0.02+H0*0.35, 0.5-L0*0.4, 1.0)\n R0, G0, B0 = colorsys.hls_to_rgb(1.0-H0*0.40, 0.5-L0*0.4, 1.0)\n\n elif mode == \"C\":\n H0 = c\n L0 = 1/(1+np.exp((-2.8*((c-0.52)*2.4))))\n R0, G0, B0 = colorsys.hls_to_rgb(0.02+H0*0.35, 0.5-L0*0.4, 1.0)\n\n elif mode == \"AC\":\n R0 = a*1.0\n # G0 = max(0.8-(max(a+c, 0)), 0)\n G0 = 0.0\n B0 = c*1.0\n\n else:\n R0 = 0.3\n G0 = 0.2\n B0 = 0.2\n\n R1 = 1.0 - R0\n G1 = 1.0 - G0\n B1 = 1.0 - B0\n\n sph.append(Sphere(v, 0.022,\n Texture(Pigment('color',\n [R0+uc*R1, G0+uc*G1, B0+uc*B1]),\n Finish('phong', 0.7,\n 'specular', 0.2,\n 'diffuse', 0.9,\n 'ambient', 0.1)),\n 'rotate', [rotx, 0, 0],\n 'rotate', [0, roty, 0],\n 'rotate', [0, 0, rotz],\n 'translate', [x, y, z],\n 'no_shadow'))\n\n return sph","def compute_magnetic_field(self, coords, params=None, basis=\"rpz\"):\n return self._scalar * self._field.compute_magnetic_field(coords, params, basis)","def velocity_field(xt,yt,x0,y0,Vinf,dia,rot,chord,B,param=None,veltype='all',integration='simp',m=220,n=200):\n rad = dia/2.\n tsr = rad*fabs(rot)/Vinf\n solidity = (chord*B)/rad\n\n # Translating the turbine position\n x0t = x0 - xt\n y0t = y0 - yt\n\n coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9 = coef_val()\n\n # Calculating EMG distribution parameters (based on polynomial surface fitting)\n if param is None:\n loc1 = _parameterval(tsr,solidity,coef0)\n loc2 = _parameterval(tsr,solidity,coef1)\n loc3 = _parameterval(tsr,solidity,coef2)\n spr1 = _parameterval(tsr,solidity,coef3)\n spr2 = _parameterval(tsr,solidity,coef4)\n skw1 = _parameterval(tsr,solidity,coef5)\n skw2 = _parameterval(tsr,solidity,coef6)\n scl1 = _parameterval(tsr,solidity,coef7)\n scl2 = _parameterval(tsr,solidity,coef8)\n scl3 = _parameterval(tsr,solidity,coef9)\n\n else:\n # Reading in EMG distribution parameters\n loc1 = param[0]\n loc2 = param[1]\n loc3 = param[2]\n spr1 = param[3]\n spr2 = param[4]\n skw1 = param[5]\n skw2 = param[6]\n scl1 = param[7]\n scl2 = param[8]\n scl3 = param[9]\n\n ###################################\n if veltype == 'vort':\n # VORTICITY CALCULATION (NO INTEGRATION)\n if x0t < 0.:\n vel = 0.\n else:\n vel = _vawtwake.vorticitystrength(x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)/rot\n ###################################\n else:\n # Integration of the vorticity profile to calculate velocity\n if integration == 'simp':\n # SIMPSON'S RULE INTEGRATION (must use polynomial surface coefficients from VAWTPolySurfaceCoef.csv)\n inte = 1 # Simpson's Rule\n # inte = 2 # Trapezoidal Rule (optional ability of the code-- faster but less accurate)\n\n if param is not None:\n print \"**** Using polynomial surface coefficients from VAWTPolySurfaceCoef.csv for Simpson's rule integration ****\"\n\n vel_xs,vel_ys = _vawtwake.vel_field(xt,yt,x0,y0,dia,rot,chord,B,Vinf,coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9,m,n,inte)\n\n if veltype == 'all':\n vel = sqrt((vel_xs*Vinf + Vinf)**2 + (vel_ys*Vinf)**2)/Vinf\n elif veltype == 'x':\n vel = (vel_xs*Vinf + Vinf)/Vinf\n elif veltype == 'y':\n vel = vel_ys\n elif veltype == 'ind':\n vel = np.array([vel_xs,vel_ys])\n ###################################\n elif integration == 'gskr':\n # 21-POINT GAUSS-KRONROD RULE QUADRATURE INTEGRATION\n xbound = (scl3+5.)*dia\n argval = (x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)\n if veltype == 'all' or veltype == 'x' or veltype == 'ind':\n vel_x = _dblquad(_vawtwake.integrandx,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\n vel_xs = (vel_x[0]*fabs(rot))/(2.*pi)\n if veltype == 'all' or veltype == 'y' or veltype == 'ind':\n vel_y = _dblquad(_vawtwake.integrandy,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\n vel_ys = (vel_y[0]*fabs(rot))/(2.*pi)\n\n if veltype == 'all':\n vel = sqrt((vel_xs + Vinf)**2 + (vel_ys)**2)/Vinf\n elif veltype == 'x':\n vel = (vel_xs + Vinf)/Vinf\n elif veltype == 'y':\n vel = vel_ys/Vinf\n elif veltype == 'ind':\n vel = np.array([vel_xs,vel_ys])/Vinf\n ###################################\n\n return vel","def move_to_point_and_extract(coords_from_to: list,\n gps: adapters.GPSUbloxAdapter,\n vesc_engine: adapters.VescAdapterV4,\n smoothie: adapters.SmoothieAdapter,\n camera: adapters.CameraAdapterIMX219_170,\n periphery_det: detection.YoloOpenCVDetection,\n precise_det: detection.YoloOpenCVDetection,\n logger_full: utility.Logger,\n report_field_names,\n trajectory_saver: utility.TrajectorySaver,\n working_zone_polygon,\n img_output_dir,\n nav: navigation.GPSComputing,\n data_collector: datacollection.DataCollector,\n log_cur_dir,\n image_saver: utility.ImageSaver,\n notification: NotificationClient,\n extraction_manager_v3: ExtractionManagerV3,\n ui_msg_queue: posix_ipc.MessageQueue,\n SI_speed: float,\n wheels_straight: bool,\n navigation_prediction: navigation.NavigationPrediction,\n future_points: list,\n allow_extractions: bool,\n x_scan_poly: list,\n cur_field):\n\n if config.ALLOW_FIELD_LEAVING_PROTECTION and cur_field is not None and len(cur_field) > 2:\n enable_field_leaving_protection = True\n else:\n enable_field_leaving_protection = False\n if config.ALLOW_FIELD_LEAVING_PROTECTION:\n if cur_field is None:\n msg = f\"WARNING: robot field leaving protection WILL NOT WORK as given field is None\"\n print(msg)\n logger_full.write(msg)\n elif len(cur_field) < 3:\n msg = f\"WARNING: robot field leaving protection WILL NOT WORK as given field contains \" \\\n f\"{len(cur_field)} points (required ar least 3 points)\"\n print(msg)\n logger_full.write(msg)\n\n extract = SI_speed > 0 and allow_extractions\n\n vesc_speed = SI_speed * config.MULTIPLIER_SI_SPEED_TO_RPM\n speed_fast = config.SI_SPEED_FAST * config.MULTIPLIER_SI_SPEED_TO_RPM\n vesc_speed_fast = speed_fast if SI_speed >= 0 else -speed_fast\n navigation_prediction.set_SI_speed(SI_speed)\n\n raw_angles_history = []\n detections_period = []\n navigations_period = []\n stop_helping_point = nav.get_coordinate(\n coords_from_to[1], coords_from_to[0], 90, 1000)\n learn_go_straight_index = 0\n learn_go_straight_history = []\n\n last_skipped_point = coords_from_to[0]\n start_Nav_while = True\n last_correct_raw_angle = 0\n point_status = \"origin\"\n last_corridor_side = 0\n current_corridor_side = 1\n almost_start = 0\n\n prev_maneuver_time = time.time()\n working_mode_slow = 1\n working_mode_fast = 2\n working_mode_switching = 3\n current_working_mode = working_mode_slow\n last_working_mode = 0\n # True if robot is close to one of current movement vector points, False otherwise; False if speed limit near points is disabled\n close_to_end = config.USE_SPEED_LIMIT\n bumper_is_pressed = None\n\n # message queue sending temporary performance tracker\n if config.QUEUE_TRACK_PERFORMANCE:\n ui_msg_queue_perf = {\n \"max_time\": 0,\n \"min_time\": float(\"inf\"),\n \"total_time\": 0,\n \"total_sends\": 0,\n \"timeouts_exceeded\": 0\n }\n\n # x movements during periphery scans\n x_scan_cur_idx = 0\n x_scan_idx_increasing = True\n\n # set camera to the Y min\n res = smoothie.custom_separate_xy_move_to(X_F=config.X_F_MAX,\n Y_F=config.Y_F_MAX,\n X=smoothie.smoothie_to_mm(\n (config.X_MAX - config.X_MIN) / 2, \"X\"),\n Y=smoothie.smoothie_to_mm(config.Y_MIN, \"Y\"))\n if res != smoothie.RESPONSE_OK:\n msg = \"INIT: Failed to move camera to Y min, smoothie response:\\n\" + res\n logger_full.write(msg + \"\\n\")\n smoothie.wait_for_all_actions_done()\n\n # TODO: maybe should add sleep time as camera currently has delay\n\n if config.AUDIT_MODE:\n vesc_engine.set_target_rpm(vesc_speed, vesc_engine.PROPULSION_KEY)\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\n\n try:\n notificationQueue = posix_ipc.MessageQueue(\n config.QUEUE_NAME_UI_NOTIFICATION)\n except KeyboardInterrupt:\n raise KeyboardInterrupt\n except:\n notificationQueue = None\n\n degraded_navigation_mode = False\n\n number_navigation_cycle_without_gps = 0\n\n point_reading_t = last_send_gps_time = slow_mode_time = time.time()\n\n have_time_for_inference = True\n predictor_next_gps_expected_ts = float(\"inf\")\n\n # main navigation control loop\n while True:\n # gps point reading time predictor\n if have_time_for_inference and config.ALLOW_GPS_TIME_PREDICTIONS_LIMITING_INFERENCE:\n if time.time() + config.INFERENCE_MAX_TICK_TIME > predictor_next_gps_expected_ts:\n have_time_for_inference = False\n\n if have_time_for_inference:\n # EXTRACTION CONTROL\n start_t = time.time()\n frame = camera.get_image()\n frame_t = time.time()\n\n per_det_start_t = time.time()\n if extract:\n plants_boxes = periphery_det.detect(frame)\n else:\n plants_boxes = list()\n per_det_end_t = time.time()\n detections_period.append(per_det_end_t - start_t)\n\n if config.SAVE_DEBUG_IMAGES:\n image_saver.save_image(\n frame,\n img_output_dir,\n label=\"PE_view_M=\" + str(current_working_mode),\n plants_boxes=plants_boxes)\n if config.ALLOW_GATHERING and current_working_mode == working_mode_slow and \\\n image_saver.get_counter(\"gathering\") < config.DATA_GATHERING_MAX_IMAGES:\n image_saver.save_image(frame, config.DATA_GATHERING_DIR,\n plants_boxes=plants_boxes, counter_key=\"gathering\")\n\n if extract:\n msg = \"View frame time: \" + str(frame_t - start_t) + \"\\t\\tPeri. det. time: \" + \\\n str(per_det_end_t - per_det_start_t)\n else:\n msg = \"View frame time: \" + str(frame_t - start_t) + \"\\t\\tPeri. det. (extractions are off) time: \" + \\\n str(per_det_end_t - per_det_start_t)\n logger_full.write(msg + \"\\n\")\n\n # MOVEMENT AND ACTIONS MODES\n if config.AUDIT_MODE:\n dc_start_t = time.time()\n\n # count detected plant boxes for each type\n plants_count = dict()\n for plant_box in plants_boxes:\n plant_box_name = plant_box.get_name()\n if plant_box_name in plants_count:\n plants_count[plant_box_name] += 1\n else:\n plants_count[plant_box_name] = 1\n\n # save info into data collector\n for plant_label in plants_count:\n data_collector.add_detections_data(plant_label,\n math.ceil((plants_count[plant_label]) / config.AUDIT_DIVIDER))\n\n # flush updates into the audit output file and log measured time\n if len(plants_boxes) > 0:\n data_collector.save_all_data(\n log_cur_dir + config.AUDIT_OUTPUT_FILE)\n\n dc_t = time.time() - dc_start_t\n msg = \"Last scan weeds detected: \" + str(len(plants_boxes)) + \\\n \", audit processing tick time: \" + str(dc_t)\n logger_full.write(msg + \"\\n\")\n else:\n # slow mode\n if current_working_mode == working_mode_slow:\n if last_working_mode != current_working_mode:\n last_working_mode = current_working_mode\n msg = \"[Working mode] : slow\"\n if config.LOG_SPEED_MODES:\n logger_full.write(msg + \"\\n\")\n if config.PRINT_SPEED_MODES:\n print(msg)\n\n if ExtractionManagerV3.any_plant_in_zone(\n plants_boxes,\n x_scan_poly[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else working_zone_polygon):\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n if config.VERBOSE_EXTRACT:\n msg = \"[VERBOSE EXTRACT] Stopping the robot because we have detected plant(s).\"\n logger_full.write_and_flush(msg+\"\\n\")\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n # TODO this 0 rpm \"movement\" is to prevent robot movement during extractions, need to add this in future to rest speed modes too\n vesc_engine.set_time_to_move(config.VESC_MOVING_TIME, vesc_engine.PROPULSION_KEY)\n vesc_engine.set_target_rpm(0, vesc_engine.PROPULSION_KEY)\n vesc_engine.set_current_rpm(0, vesc_engine.PROPULSION_KEY)\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\n\n # TODO remove thread init from here!\n voltage_thread = threading.Thread(\n target=send_voltage_thread_tf,\n args=(vesc_engine, ui_msg_queue),\n daemon=True)\n voltage_thread.start()\n\n # single precise center scan before calling for PDZ scanning and extractions\n if config.ALLOW_PRECISE_SINGLE_SCAN_BEFORE_PDZ and not config.ALLOW_X_MOVEMENT_DURING_SCANS:\n time.sleep(config.DELAY_BEFORE_2ND_SCAN)\n frame = camera.get_image()\n plants_boxes = precise_det.detect(frame)\n\n # do PDZ scan and extract all plants if single precise scan got plants in working area\n if ExtractionManagerV3.any_plant_in_zone(plants_boxes, working_zone_polygon):\n if config.EXTRACTION_MODE == 1:\n extraction_manager_v3.extract_all_plants()\n elif config.EXTRACTION_MODE == 2:\n extraction_manager_v3.mill_all_plants()\n slow_mode_time = time.time()\n else:\n if config.EXTRACTION_MODE == 1:\n extraction_manager_v3.extract_all_plants()\n elif config.EXTRACTION_MODE == 2:\n extraction_manager_v3.mill_all_plants()\n slow_mode_time = time.time()\n\n if config.VERBOSE_EXTRACT:\n msg = \"[VERBOSE EXTRACT] Extract cycle are finish.\"\n logger_full.write_and_flush(msg+\"\\n\")\n\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n\n msg = \"Applying force step forward after extractions cycle(s)\"\n logger_full.write(msg + \"\\n\")\n if config.VERBOSE:\n print(msg)\n vesc_engine.set_time_to_move(config.STEP_FORWARD_TIME, vesc_engine.PROPULSION_KEY)\n vesc_engine.set_target_rpm(\n config.SI_SPEED_STEP_FORWARD * config.MULTIPLIER_SI_SPEED_TO_RPM,\n vesc_engine.PROPULSION_KEY)\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\n vesc_engine.wait_for_stop(vesc_engine.PROPULSION_KEY)\n\n elif config.SLOW_FAST_MODE and time.time() - slow_mode_time > config.SLOW_MODE_MIN_TIME:\n # move cork to fast mode scan position\n if config.VERBOSE:\n msg = \"SLOW MODE: moving cork to fast mode position\\n\"\n logger_full.write(msg)\n\n res = smoothie.custom_separate_xy_move_to(\n X_F=config.X_F_MAX,\n Y_F=config.Y_F_MAX,\n X=smoothie.smoothie_to_mm(\n (config.X_MAX - config.X_MIN) / 2, \"X\"),\n Y=smoothie.smoothie_to_mm((config.Y_MAX - config.Y_MIN) * config.SLOW_FAST_MODE_HEAD_FACTOR,\n \"Y\"))\n if res != smoothie.RESPONSE_OK:\n msg = \"INIT: Keeping in slow mode as failed to move camera to fast mode scan position, smoothie's response:\\n\" + res\n logger_full.write(msg + \"\\n\")\n else:\n msg = \"Switching from 'slow mode' to 'switching mode'\"\n if config.LOG_SPEED_MODES:\n logger_full.write(msg + \"\\n\")\n if config.PRINT_SPEED_MODES:\n print(msg)\n current_working_mode = working_mode_switching\n\n # TODO a bug: will not start moving if config.SLOW_MODE_MIN_TIME == 0 or too low (switch speed applies right after slow mode weeds extractions)\n if not vesc_engine.is_moving(vesc_engine.PROPULSION_KEY):\n vesc_engine.set_time_to_move(config.VESC_MOVING_TIME, vesc_engine.PROPULSION_KEY)\n vesc_engine.set_target_rpm(vesc_speed, vesc_engine.PROPULSION_KEY)\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\n\n # switching (from slow to fast) mode\n elif current_working_mode == working_mode_switching:\n if last_working_mode != current_working_mode:\n last_working_mode = current_working_mode\n msg = \"[Working mode] : switching to fast\"\n if config.LOG_SPEED_MODES:\n logger_full.write(msg + \"\\n\")\n if config.PRINT_SPEED_MODES:\n print(msg)\n\n if ExtractionManagerV3.any_plant_in_zone(\n plants_boxes,\n x_scan_poly[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else working_zone_polygon):\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n\n if config.VERBOSE:\n msg = \"Moving cork to slow mode scan position\\n\"\n logger_full.write(msg)\n\n # smoothie.wait_for_all_actions_done()\n res = smoothie.custom_separate_xy_move_to(\n X_F=config.X_F_MAX,\n Y_F=config.Y_F_MAX,\n X=smoothie.smoothie_to_mm(\n (config.X_MAX - config.X_MIN) / 2, \"X\"),\n Y=smoothie.smoothie_to_mm(config.Y_MIN, \"Y\"))\n if res != smoothie.RESPONSE_OK:\n msg = \"INIT: Failed to move camera to Y min, smoothie response:\\n\" + res\n logger_full.write(msg + \"\\n\")\n smoothie.wait_for_all_actions_done()\n\n current_working_mode = working_mode_slow\n slow_mode_time = time.time()\n vesc_engine.set_target_rpm(\n vesc_speed, vesc_engine.PROPULSION_KEY)\n continue\n\n sm_cur_pos = smoothie.get_smoothie_current_coordinates(\n convert_to_mms=False)\n if abs(sm_cur_pos[\"X\"] - (config.X_MAX - config.X_MIN) / 2) < 0.001 and \\\n abs(sm_cur_pos[\"Y\"] - (config.Y_MAX - config.Y_MIN) * config.SLOW_FAST_MODE_HEAD_FACTOR) < 0.001:\n msg = \"Switching from 'switching mode' to 'fast mode'\"\n if config.LOG_SPEED_MODES:\n logger_full.write(msg + \"\\n\")\n if config.PRINT_SPEED_MODES:\n print(msg)\n current_working_mode = working_mode_fast\n\n # fast mode\n elif current_working_mode == working_mode_fast:\n if last_working_mode != current_working_mode:\n last_working_mode = current_working_mode\n msg = \"[Working mode] : fast\"\n if config.LOG_SPEED_MODES:\n logger_full.write_and_flush(msg + \"\\n\")\n if config.PRINT_SPEED_MODES:\n print(msg)\n\n if ExtractionManagerV3.any_plant_in_zone(\n plants_boxes,\n x_scan_poly[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else working_zone_polygon):\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n\n if config.VERBOSE:\n msg = \"Moving cork to slow mode scan position\\n\"\n logger_full.write(msg)\n\n # smoothie.wait_for_all_actions_done()\n res = smoothie.custom_separate_xy_move_to(\n X_F=config.X_F_MAX,\n Y_F=config.Y_F_MAX,\n X=smoothie.smoothie_to_mm(\n (config.X_MAX - config.X_MIN) / 2, \"X\"),\n Y=smoothie.smoothie_to_mm(config.Y_MIN, \"Y\"))\n if res != smoothie.RESPONSE_OK:\n msg = \"INIT: Failed to move camera to Y min, smoothie response:\\n\" + res\n logger_full.write(msg + \"\\n\")\n smoothie.wait_for_all_actions_done()\n\n msg = \"Switching from 'fast mode' to 'slow mode'\"\n if config.LOG_SPEED_MODES:\n logger_full.write(msg + \"\\n\")\n if config.PRINT_SPEED_MODES:\n print(msg)\n current_working_mode = working_mode_slow\n slow_mode_time = time.time()\n # TODO dont need anymore? as rpm is set at the end of slow mode\n # vesc_engine.set_rpm(vesc_speed, vesc_engine.PROPULSION_KEY)\n continue\n elif close_to_end:\n cur_vesc_rpm = vesc_engine.get_current_rpm(\n vesc_engine.PROPULSION_KEY)\n if cur_vesc_rpm != vesc_speed:\n msg = f\"Applying slow speed {vesc_speed} at 'fast mode' \" \\\n f\"(was {cur_vesc_rpm}) \" \\\n f\"because of close_to_end flag trigger\"\n if config.LOG_SPEED_MODES:\n logger_full.write(msg + \"\\n\")\n if config.PRINT_SPEED_MODES:\n print(msg)\n vesc_engine.set_target_rpm(\n vesc_speed, vesc_engine.PROPULSION_KEY)\n vesc_engine.set_current_rpm(\n vesc_speed, vesc_engine.PROPULSION_KEY)\n else:\n cur_vesc_rpm = vesc_engine.get_current_rpm(\n vesc_engine.PROPULSION_KEY)\n if cur_vesc_rpm != vesc_speed_fast:\n msg = f\"Applying fast speed {vesc_speed_fast} at 'fast mode' (was {cur_vesc_rpm})\"\n if config.LOG_SPEED_MODES:\n logger_full.write(msg + \"\\n\")\n if config.PRINT_SPEED_MODES:\n print(msg)\n vesc_engine.set_target_rpm(\n vesc_speed_fast, vesc_engine.PROPULSION_KEY)\n vesc_engine.set_current_rpm(\n vesc_speed_fast, vesc_engine.PROPULSION_KEY)\n\n # NAVIGATION CONTROL\n cur_pos_obj = gps.get_last_position_v2()\n cur_pos = cur_pos_obj.as_old_list\n\n nav_start_t = time.time()\n\n if start_Nav_while:\n navigation_period = 1\n else:\n navigation_period = nav_start_t - prev_maneuver_time\n\n navigations_period.append(navigation_period)\n # time reference to decide the number of detection before resuming gps.get\n prev_maneuver_time = nav_start_t\n # print(\"tock\")\n\n if start_Nav_while:\n prev_pos_obj = cur_pos_obj\n prev_pos = prev_pos_obj.as_old_list\n start_Nav_while = False\n\n # mu_navigations_period, sigma_navigations_period = utility.mu_sigma(navigations_period)\n\n navigation_prediction.set_current_lat_long(cur_pos)\n\n # skip same points (non-blocking reading returns old point if new point isn't available yet)\n if math.isclose(cur_pos_obj.creation_ts, prev_pos_obj.creation_ts):\n # stop robot if there's no new points for a while\n if time.time() - point_reading_t > config.GPS_POINT_TIME_BEFORE_STOP:\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n msg = f\"Stopping the robot due to exceeding time 'GPS_POINT_TIME_BEFORE_STOP=\" \\\n f\"{config.GPS_POINT_TIME_BEFORE_STOP}' limit without new gps points from adapter\"\n logger_full.write_and_flush(msg + \"\\n\")\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n\n gps_reconnect_ts = time.time()\n\n while True:\n cur_pos_obj = gps.get_last_position_v2()\n cur_pos = cur_pos_obj.as_old_list\n\n if math.isclose(cur_pos_obj.creation_ts, prev_pos_obj.creation_ts):\n # reconnect gps adapter to ublox if there's no gps points for a while\n if time.time() - gps_reconnect_ts > config.GPS_POINT_TIME_BEFORE_RECONNECT:\n gps.reconnect()\n gps_reconnect_ts = time.time()\n msg = \"Called GPS adapter to reconnect to ublox due to waiting too much for a new GPS \" \\\n \"point (new points filter)\"\n if config.VERBOSE:\n print(msg)\n logger_full.write_and_flush(msg + \"\\n\")\n else:\n msg = \"New GPS point received, continuing movement\"\n logger_full.write_and_flush(msg + \"\\n\")\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\n break\n else:\n continue\n\n # gps points reading time predictor\n predictor_next_gps_expected_ts = cur_pos_obj.receiving_ts + config.GPS_POINT_WAIT_TIME_MAX\n have_time_for_inference = True\n\n # points filter by quality flag\n if cur_pos[2] != \"4\" and config.ALLOW_GPS_BAD_QUALITY_NTRIP_RESTART:\n # restart ntrip if enough time passed since the last ntrip restart\n navigation.NavigationV3.restart_ntrip_service(logger_full)\n\n # stop robot due to bad point quality if allowed\n if config.ALLOW_GPS_BAD_QUALITY_STOP:\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n logger_full.write_and_flush(\n \"Stopping the robot for lack of quality gps 4, waiting for it...\\n\")\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n\n prev_bad_quality_pos_obj = cur_pos_obj\n gps_reconnect_ts = time.time()\n\n while True:\n cur_pos_obj = gps.get_last_position_v2()\n cur_pos = cur_pos_obj.as_old_list\n\n # check if it's a new point\n if math.isclose(cur_pos_obj.creation_ts, prev_bad_quality_pos_obj.creation_ts):\n # reconnect gps adapter to ublox if there's no gps points for a while\n if time.time() - gps_reconnect_ts > config.GPS_POINT_TIME_BEFORE_RECONNECT:\n gps.reconnect()\n gps_reconnect_ts = time.time()\n msg = \"Called GPS adapter to reconnect to ublox due to waiting too much for a new \" \\\n \"GPS point (quality filter)\"\n if config.VERBOSE:\n print(msg)\n logger_full.write_and_flush(msg + \"\\n\")\n continue\n else:\n prev_bad_quality_pos_obj = cur_pos_obj\n\n # check if it's a good quality point\n if cur_pos[2] != \"4\":\n # restart ntrip if enough time passed since the last ntrip restart\n navigation.NavigationV3.restart_ntrip_service(\n logger_full)\n else:\n msg = \"The gps has regained quality 4, starting movement\"\n if config.VERBOSE:\n print(msg)\n logger_full.write_and_flush(msg + \"\\n\")\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\n break\n\n # points filter by distance\n prev_cur_distance = nav.get_distance(prev_pos, cur_pos)\n if config.ALLOW_GPS_PREV_CUR_DIST_STOP and prev_cur_distance > config.PREV_CUR_POINT_MAX_DIST:\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n msg = f\"Stopping the robot due to GPS points filter by distance (assuming current position point \" \\\n f\"{str(cur_pos)} is wrong as distance between current position and prev. position {str(prev_pos)}\" \\\n f\" is bigger than config.PREV_CUR_POINT_MAX_DIST={str(config.PREV_CUR_POINT_MAX_DIST)})\"\n logger_full.write_and_flush(msg + \"\\n\")\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n\n prev_bad_quality_pos_obj = cur_pos_obj\n gps_reconnect_ts = distance_wait_start_ts = time.time()\n\n while True:\n if time.time() - distance_wait_start_ts > config.GPS_DIST_WAIT_TIME_MAX:\n msg = f\"Stopping waiting for good prev-cur distance due to timeout, using current point \" \\\n f\"{cur_pos} and starting moving again\"\n if config.VERBOSE:\n print(msg)\n logger_full.write_and_flush(msg + \"\\n\")\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\n break\n\n cur_pos_obj = gps.get_last_position_v2()\n cur_pos = cur_pos_obj.as_old_list\n\n # check if it's a new point\n if math.isclose(cur_pos_obj.creation_ts, prev_bad_quality_pos_obj.creation_ts):\n # reconnect gps adapter to ublox if there's no gps points for a while\n if time.time() - gps_reconnect_ts > config.GPS_POINT_TIME_BEFORE_RECONNECT:\n gps.reconnect()\n gps_reconnect_ts = time.time()\n msg = \"Called GPS adapter to reconnect to ublox due to waiting too much for a new \" \\\n \"GPS point (distance filter)\"\n if config.VERBOSE:\n print(msg)\n logger_full.write_and_flush(msg + \"\\n\")\n continue\n else:\n prev_bad_quality_pos_obj = cur_pos_obj\n\n # check if it's a good quality point or ignore point quality if bad quality stop is not allowed\n if cur_pos[2] != \"4\" and config.ALLOW_GPS_BAD_QUALITY_NTRIP_RESTART:\n # restart ntrip if enough time passed since the last ntrip restart\n navigation.NavigationV3.restart_ntrip_service(logger_full)\n continue\n\n # check if distance became ok\n prev_cur_distance = nav.get_distance(prev_pos, cur_pos)\n if prev_cur_distance <= config.PREV_CUR_POINT_MAX_DIST:\n msg = f\"Starting moving again after GPS points filter by distance as distance become OK \" \\\n f\"({str(prev_cur_distance)})\"\n logger_full.write_and_flush(msg + \"\\n\")\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\n break\n\n point_reading_t = time.time()\n\n trajectory_saver.save_point(cur_pos)\n if ui_msg_queue is not None and time.time()-last_send_gps_time >= 1:\n try:\n ui_msg_queue_send_ts = time.time()\n ui_msg_queue.send(json.dumps(\n {\"last_gps\": cur_pos}), timeout=config.QUEUE_WAIT_TIME_MAX)\n last_send_gps_time = time.time()\n\n if config.QUEUE_TRACK_PERFORMANCE:\n ui_msg_queue_send_et = last_send_gps_time - ui_msg_queue_send_ts\n if ui_msg_queue_send_et < ui_msg_queue_perf[\"min_time\"]:\n ui_msg_queue_perf[\"min_time\"] = ui_msg_queue_send_et\n if ui_msg_queue_send_et > ui_msg_queue_perf[\"max_time\"]:\n ui_msg_queue_perf[\"max_time\"] = ui_msg_queue_send_et\n ui_msg_queue_perf[\"total_time\"] += ui_msg_queue_send_et\n ui_msg_queue_perf[\"total_sends\"] += 1\n except posix_ipc.BusyError:\n msg = f\"Current position wasn't sent to ui_msg_queue likely due to sending timeout \" \\\n f\"(max wait time: config.QUEUE_WAIT_TIME_MAX={config.QUEUE_WAIT_TIME_MAX}\"\n logger_full.write(msg + \"\\n\")\n\n if config.QUEUE_TRACK_PERFORMANCE:\n ui_msg_queue_perf[\"timeouts_exceeded\"] += 1\n\n if config.CONTINUOUS_INFORMATION_SENDING and not degraded_navigation_mode:\n notification.set_current_coordinate(cur_pos)\n\n distance = nav.get_distance(cur_pos, coords_from_to[1])\n\n last_corridor_side = current_corridor_side\n perpendicular, current_corridor_side = nav.get_deviation(\n coords_from_to[0], coords_from_to[1], cur_pos)\n\n # stop the robot if it has left the field\n if enable_field_leaving_protection:\n for pt_idx in range(len(cur_field)):\n last_point = pt_idx + 1 == len(cur_field)\n\n if last_point:\n deviation, side = nav.get_deviation(cur_field[pt_idx], cur_field[0], cur_pos)\n else:\n deviation, side = nav.get_deviation(cur_field[pt_idx], cur_field[pt_idx + 1], cur_pos)\n\n if side == -1 and deviation > config.LEAVING_PROTECTION_DISTANCE_MAX:\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n msg = f\"Robot is stopped due to leaving the field. Cur pos: '{str(cur_pos)}'; \" \\\n f\"Field comparison vector - P1: '{str(cur_field[pt_idx])}', \" \\\n f\"P2: '{str(cur_field[0] if last_point else cur_field[pt_idx + 1])}'\"\n print(msg)\n logger_full.write_and_flush(msg + \"\\n\")\n notification.set_robot_state(RobotStates.OUT_OF_SERVICE)\n exit()\n\n # check if arrived\n _, side = nav.get_deviation(\n coords_from_to[1], stop_helping_point, cur_pos)\n # if distance <= config.COURSE_DESTINATION_DIFF: # old way\n if side != 1: # TODO: maybe should use both side and distance checking methods at once\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n # msg = \"Arrived (allowed destination distance difference \" + str(config.COURSE_DESTINATION_DIFF) + \" mm)\"\n # TODO: service will reload script even if it done his work?\n msg = \"Arrived to \" + str(coords_from_to[1])\n # print(msg)\n logger_full.write(msg + \"\\n\")\n\n # put the wheel straight\n if wheels_straight:\n response = smoothie.custom_move_to(A_F=config.A_F_MAX, A=0)\n if response != smoothie.RESPONSE_OK: # TODO: what if response is not ok?\n msg = \"Couldn't turn wheels to center (0), smoothie response:\\n\" + \\\n response\n print(msg)\n logger_full.write(msg + \"\\n\")\n else:\n # save wheels angle\n with open(config.LAST_ANGLE_WHEELS_FILE, \"w+\") as wheels_angle_file:\n wheels_angle_file.write(\n str(smoothie.get_adapter_current_coordinates()[\"A\"]))\n break\n\n # TODO check for bug: arrival check applies single speed for all path (while multiple speeds are applied)\n # check if can arrived\n if vesc_engine.get_current_rpm(vesc_engine.PROPULSION_KEY) / config.MULTIPLIER_SI_SPEED_TO_RPM * \\\n config.MANEUVERS_FREQUENCY > nav.get_distance(cur_pos, coords_from_to[1]):\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\n data_collector.add_vesc_moving_time_data(\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\n msg = \"Will have arrived before the next point to \" + \\\n str(coords_from_to[1])\n # print(msg)\n logger_full.write(msg + \"\\n\")\n\n break\n\n # reduce speed if near the target point\n if config.USE_SPEED_LIMIT:\n distance_from_start = nav.get_distance(coords_from_to[0], cur_pos)\n close_to_end = distance < config.DECREASE_SPEED_TRESHOLD or distance_from_start < config.DECREASE_SPEED_TRESHOLD\n\n msg = \"Distance to B: \" + str(distance)\n # print(msg)\n logger_full.write(msg + \"\\n\")\n\n msg = \"Prev: \" + str(prev_pos) + \" Cur: \" + str(cur_pos) + \" A: \" + str(coords_from_to[0]) \\\n + \" B: \" + str(coords_from_to[1])\n # print(msg)\n logger_full.write(msg + \"\\n\")\n\n # pass by cur points which are very close to prev point to prevent angle errors when robot is staying\n # (too close points in the same position can produce false huge angles)\n\n navigation_prediction.run_prediction(coords_from_to, cur_pos)\n\n # raw_angle_cruise = nav.get_angle(coords_from_to[0], cur_pos, cur_pos, coords_from_to[1])\n # raw_angle_legacy = nav.get_angle(prev_pos, cur_pos, cur_pos, coords_from_to[1])\n raw_angle_centroid = nav.get_angle(\n prev_pos, cur_pos, coords_from_to[0], coords_from_to[1])\n raw_angle_cruise = - current_corridor_side * math.log(1+perpendicular)\n\n if nav.get_distance(coords_from_to[0], coords_from_to[1]) < config.CORNER_THRESHOLD and nav.get_distance(coords_from_to[1], future_points[0][0]) < config.CORNER_THRESHOLD:\n # if abs(raw_angle_legacy)>config.LOST_THRESHOLD:\n centroid_factor = config.CENTROID_FACTOR_LOST\n cruise_factor = 1/centroid_factor\n else:\n centroid_factor = config.CENTROID_FACTOR_ORIENTED\n cruise_factor = 1\n\n raw_angle = raw_angle_centroid*centroid_factor + raw_angle_cruise*cruise_factor\n\n # raw_angle = butter_lowpass_filter(raw_angle, 0.5, 4, 6)\n\n if config.LEARN_GO_STRAIGHT:\n if config.MIN_PERPENDICULAR_GO_STRAIGHT >= perpendicular:\n learn_go_straight_index += 1\n learn_go_straight_history.append(raw_angle)\n if len(learn_go_straight_history) >= config.VALUES_LEARN_GO_STRAIGHT:\n learn_go_straight = sum(\n learn_go_straight_history)/len(learn_go_straight_history)\n msg = f\"Average angle applied to the wheel for the robot to have found : {learn_go_straight}.\"\n logger_full.write_and_flush(msg + \"\\n\")\n # TODO opening and closing file 4 times per second\n with open(config.LEARN_GO_STRAIGHT_FILE, \"w+\") as learn_go_straight_file:\n learn_go_straight_file.write(str(learn_go_straight))\n else:\n learn_go_straight_index = 0\n\n # NAVIGATION STATE MACHINE\n if prev_cur_distance < config.PREV_CUR_POINT_MIN_DIST:\n raw_angle = last_correct_raw_angle\n # print(\"The distance covered is low\")\n point_status = \"skipped\"\n\n # register the last position where the robot almost stop\n # in order to disable the deviation servo for a config.POURSUIT_LIMIT length and then resume in cruise\n last_skipped_point = cur_pos\n else:\n last_correct_raw_angle = raw_angle\n point_status = \"correct\"\n\n almost_start = nav.get_distance(last_skipped_point, cur_pos)\n\n # sum(e)\n if len(raw_angles_history) >= config.WINDOW:\n raw_angles_history.pop(0)\n raw_angles_history.append(raw_angle)\n # print(\"len(raw_angles_history):\",len(raw_angles_history))\n sum_angles = sum(raw_angles_history)\n if sum_angles > config.SUM_ANGLES_HISTORY_MAX:\n msg = \"Sum angles \" + str(sum_angles) + \" is bigger than max allowed value \" + \\\n str(config.SUM_ANGLES_HISTORY_MAX) + \", setting to \" + \\\n str(config.SUM_ANGLES_HISTORY_MAX)\n # print(msg)\n logger_full.write(msg + \"\\n\")\n # Get Ready to go down as soon as the angle get negatif\n raw_angles_history[len(raw_angles_history) -\n 1] -= sum_angles - config.SUM_ANGLES_HISTORY_MAX\n sum_angles = config.SUM_ANGLES_HISTORY_MAX\n elif sum_angles < -config.SUM_ANGLES_HISTORY_MAX:\n msg = \"Sum angles \" + str(sum_angles) + \" is less than min allowed value \" + \\\n str(-config.SUM_ANGLES_HISTORY_MAX) + \", setting to \" + \\\n str(-config.SUM_ANGLES_HISTORY_MAX)\n # print(msg)\n logger_full.write(msg + \"\\n\")\n # get Ready to go up as soon as the angle get positive:\n raw_angles_history[len(raw_angles_history)-1] += - \\\n sum_angles - config.SUM_ANGLES_HISTORY_MAX\n sum_angles = -config.SUM_ANGLES_HISTORY_MAX\n\n # KP = 0.2*0,55\n # KI = 0.0092*0,91\n\n KP = getSpeedDependentConfigParam(\n config.KP, SI_speed, \"KP\", logger_full)\n KI = getSpeedDependentConfigParam(\n config.KI, SI_speed, \"KI\", logger_full)\n\n angle_kp_ki = raw_angle * KP + sum_angles * KI\n\n # smoothie -Value == left, Value == right\n target_angle_sm = angle_kp_ki * -config.A_ONE_DEGREE_IN_SMOOTHIE\n # target_angle_sm = 0 #Debug COVID_PLACE\n ad_wheels_pos = smoothie.get_adapter_current_coordinates()[\"A\"]\n # sm_wheels_pos = smoothie.get_smoothie_current_coordinates()[\"A\"]\n sm_wheels_pos = \"off\"\n\n # compute order angle (smoothie can't turn for huge values immediately also as cancel movement,\n # so we need to do nav. actions in steps)\n order_angle_sm = target_angle_sm - ad_wheels_pos\n\n # check for out of update frequency and smoothie execution speed range (for nav wheels)\n if order_angle_sm > config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND * \\\n config.A_ONE_DEGREE_IN_SMOOTHIE:\n msg = \"Order angle changed from \" + str(order_angle_sm) + \" to \" + str(\n config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND +\n config.A_ONE_DEGREE_IN_SMOOTHIE) + \" due to exceeding degrees per tick allowed range.\"\n # print(msg)\n logger_full.write(msg + \"\\n\")\n order_angle_sm = config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND * \\\n config.A_ONE_DEGREE_IN_SMOOTHIE\n elif order_angle_sm < -(config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND *\n config.A_ONE_DEGREE_IN_SMOOTHIE):\n msg = \"Order angle changed from \" + str(order_angle_sm) + \" to \" + str(-(\n config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND *\n config.A_ONE_DEGREE_IN_SMOOTHIE)) + \" due to exceeding degrees per tick allowed range.\"\n # print(msg)\n logger_full.write(msg + \"\\n\")\n order_angle_sm = -(config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND *\n config.A_ONE_DEGREE_IN_SMOOTHIE)\n\n # convert to global smoothie coordinates\n order_angle_sm += ad_wheels_pos\n\n # checking for out of smoothie supported range\n if order_angle_sm > config.A_MAX:\n msg = \"Global order angle changed from \" + str(order_angle_sm) + \" to config.A_MAX = \" + \\\n str(config.A_MAX) + \\\n \" due to exceeding smoothie allowed values range.\"\n # print(msg)\n logger_full.write(msg + \"\\n\")\n order_angle_sm = config.A_MAX\n elif order_angle_sm < config.A_MIN:\n msg = \"Global order angle changed from \" + str(order_angle_sm) + \" to config.A_MIN = \" + \\\n str(config.A_MIN) + \\\n \" due to exceeding smoothie allowed values range.\"\n # print(msg)\n logger_full.write(msg + \"\\n\")\n order_angle_sm = config.A_MIN\n\n # cork x movement during periphery scans control\n if config.ALLOW_X_MOVEMENT_DURING_SCANS:\n if x_scan_idx_increasing:\n x_scan_cur_idx += 1\n if x_scan_cur_idx >= len(config.X_MOVEMENT_CAMERA_POSITIONS):\n x_scan_idx_increasing = False\n x_scan_cur_idx -= 2\n else:\n x_scan_cur_idx -= 1\n if x_scan_cur_idx < 0:\n x_scan_idx_increasing = True\n x_scan_cur_idx += 2\n # TODO do we check SI_speed earlier and do proper calculations and angle validations if here we'll get here a negative order angle instead of positive?\n response = smoothie.custom_move_to(\n A_F=config.A_F_MAX,\n A=order_angle_sm if SI_speed >= 0 else -order_angle_sm,\n X_F=config.X_MOVEMENT_CAMERA_X_F[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else None,\n X=config.X_MOVEMENT_CAMERA_POSITIONS[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else None\n )\n\n if response != smoothie.RESPONSE_OK:\n msg = \"Couldn't turn wheels! Smoothie response:\\n\" + response\n print(msg)\n logger_full.write(msg + \"\\n\")\n else:\n # TODO opening and closing file too often (likely 4 times per second)\n # save wheels angle\n with open(config.LAST_ANGLE_WHEELS_FILE, \"w+\") as wheels_angle_file:\n wheels_angle_file.write(\n str(smoothie.get_adapter_current_coordinates()[\"A\"]))\n\n raw_angle = round(raw_angle, 2)\n angle_kp_ki = round(angle_kp_ki, 2)\n order_angle_sm = round(order_angle_sm, 2)\n sum_angles = round(sum_angles, 2)\n distance = round(distance, 2)\n ad_wheels_pos = round(ad_wheels_pos, 2)\n perpendicular = round(perpendicular, 2)\n # sm_wheels_pos = round(sm_wheels_pos, 2)\n gps_quality = cur_pos[2]\n corridor = \"\"\n if current_corridor_side == -1:\n corridor = \"left\"\n elif current_corridor_side == 1:\n corridor = \"right\"\n\n raw_angle_cruise = round(raw_angle_cruise, 2)\n\n msg = str(gps_quality).ljust(5) + \\\n str(raw_angle).ljust(8) + \\\n str(angle_kp_ki).ljust(8) + \\\n str(order_angle_sm).ljust(8) + \\\n str(sum_angles).ljust(8) + \\\n str(distance).ljust(13) + \\\n str(ad_wheels_pos).ljust(8) + \\\n str(sm_wheels_pos).ljust(9) + \\\n point_status.ljust(12) + \\\n str(perpendicular).ljust(10) + \\\n corridor.ljust(9) + \\\n str(centroid_factor).ljust(16) + \\\n str(cruise_factor).ljust(14)\n print(msg)\n logger_full.write(msg + \"\\n\")\n\n # TODO vesc sensors are being asked 4 times per second\n # send voltage and track bumper state\n vesc_data = vesc_engine.get_sensors_data(\n report_field_names, vesc_engine.PROPULSION_KEY)\n if vesc_data is not None and \"input_voltage\" in vesc_data:\n if bumper_is_pressed is None:\n bumper_is_pressed = not vesc_data[\"input_voltage\"] > config.VESC_BUMBER_UNTRIGGER_VOLTAGE\n if bumper_is_pressed:\n msg = f\"Bumper is pressed initially before starting moving to point. \" \\\n f\"({vesc_data['input_voltage']}V)\"\n logger_full.write(msg + \"\\n\")\n elif not bumper_is_pressed and vesc_data[\"input_voltage\"] < config.VESC_BUMBER_TRIGGER_VOLTAGE:\n bumper_is_pressed = True\n msg = f\"Bumper was pressed. ({vesc_data['input_voltage']}V)\"\n logger_full.write(msg + \"\\n\")\n elif bumper_is_pressed and vesc_data[\"input_voltage\"] > config.VESC_BUMBER_UNTRIGGER_VOLTAGE:\n bumper_is_pressed = False\n msg = f\"Bumper was unpressed. ({vesc_data['input_voltage']}V)\"\n logger_full.write(msg + \"\\n\")\n\n if config.CONTINUOUS_INFORMATION_SENDING:\n notification.set_input_voltage(vesc_data[\"input_voltage\"])\n\n prev_pos_obj = cur_pos_obj\n prev_pos = prev_pos_obj.as_old_list\n\n msg = \"Nav calc time: \" + str(time.time() - nav_start_t)\n logger_full.write(msg + \"\\n\\n\")\n\n if config.QUEUE_TRACK_PERFORMANCE:\n ui_msg_queue_perf[\"avg_time\"] = ui_msg_queue_perf[\"total_time\"] / \\\n ui_msg_queue_perf[\"total_sends\"]\n msg = f\"Position sending performance report: {ui_msg_queue_perf}\"\n if config.VERBOSE:\n print(msg)\n logger_full.write(msg + \"\\n\")","def search_base_angles(self, motor_positions):\n\n # Errore nelle soluzioni\n err = [0, 0, 0]\n\n # Angolo di inizio ricerca\n # Se gia' eseguita una conversione suo i valori precedenti\n if self.isLastAnglesValid:\n self.alpha_start = list(self.alpha)\n else:\n # Angolo minimo di partenza ( -alpha_limit )\n # TO_CHECK: perche' parto da una configurazione sicuramente errata? -10?\n self.alpha_start = [self.alpha_limit_r, self.alpha_limit_r, self.alpha_limit_r]\n\n # Angoli presunti\n # self.temp = list(self.alpha_start)\n alpha = list(self.alpha_start)\n\n # Altezze reali degli attuatori\n height = [self.real_height + motor_positions[0],\n self.real_height + motor_positions[1],\n self.real_height + motor_positions[2]]\n\n # Trovo il mediano tra 0-1-2\n '''\n if any([all([motor_positions[0] > motor_positions[1], motor_positions[0] < motor_positions[2]]),\n all([motor_positions[0] < motor_positions[1], motor_positions[0] > motor_positions[2]])]):\n is_0_median = True\n is_1_median = False\n is_2_median = False\n else:\n is_0_median = False\n if any([all([motor_positions[1] > motor_positions[2], motor_positions[1] < motor_positions[0]]),\n all([motor_positions[1] < motor_positions[2], motor_positions[1] > motor_positions[0]])]):\n is_0_median = False\n is_1_median = True\n is_2_median = False\n else:\n is_1_median = False\n if any([all([motor_positions[2] > motor_positions[1], motor_positions[2] < motor_positions[0]]),\n all([motor_positions[2] < motor_positions[1], motor_positions[2] > motor_positions[0]])]):\n is_0_median = False\n is_1_median = False\n is_2_median = True\n else:\n is_2_median = False\n '''\n\n # Incrementi degli angoli\n # TO_CHECK: perche' quattro? L'ultimo e' di backup?\n step_alpha_base = 0.1 * Kinematic.M_TO_RAD\n step_alpha = [step_alpha_base, step_alpha_base, step_alpha_base]\n\n # Numero di cicli eseguiti\n self.cycles = 0\n\n # Calcolo la condizione iniziale\n d1 = self.distance_12(alpha, height)\n err[0] = d1 - self.base_length\n step_alpha[1] = err[0] * self.ke * step_alpha_base\n\n d2 = self.distance_23(alpha, height)\n err[1] = d2 - self.base_length\n step_alpha[2] = err[1] * self.ke * step_alpha_base\n\n d3 = self.distance_13(alpha, height)\n err[2] = d3 - self.base_length\n step_alpha[0] = err[2] * self.ke * step_alpha_base\n\n i = 0\n while i < self.cycle_limit:\n\n i += 1\n\n # Incremento alfa1 ed azzero alfa2\n alpha[0] += step_alpha[0]\n alpha[1] = self.alpha_start[1]\n\n j = 0\n\n while j < self.cycle_limit:\n\n j += 1\n\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\n self.cycles += 1\n\n if self.cycles > self.cycle_limit:\n logging.error(\"Maximum number of cycles executed, no solution found!\")\n return False\n\n # Incremento alfa1 ed azzero alfa2\n alpha[1] += step_alpha[1]\n\n # Se supero l'angolo limite\n # Partendo da -10 ( -0.17 ), non devo superare 10 ( 0.17 )\n if alpha[1] > -self.alpha_limit_r:\n\n # Angolo non trovato\n step_alpha[1] = step_alpha_base\n step_alpha[0] = err[0] * step_alpha_base * self.ke\n self.alpha_start[1] = -self.alpha_limit_r - 2 * step_alpha[1]\n break\n\n d1 = self.distance_12(alpha, height)\n err[0] = d1 - self.base_length\n step_alpha[1] = err[0] * self.ke * step_alpha_base\n\n if abs(err[0]) < self.err_limit:\n\n # Trovato il minimo\n self.alpha_start[1] = alpha[1]\n step_alpha[1] = step_alpha_base\n\n n = 0\n while n < self.cycle_limit:\n\n n += 1\n\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\n self.cycles += 1\n\n if self.cycles > self.cycle_limit:\n logging.error(\"Maximum number of cycles executed, no solution found!\")\n return False\n\n alpha[2] += step_alpha[2]\n d2 = self.distance_23(alpha, height)\n err[1] = d2 - self.base_length\n step_alpha[2] = err[1] * self.ke * step_alpha_base\n\n if abs(err[1]) < self.err_limit:\n\n step_alpha[2] = step_alpha_base\n d3 = self.distance_13(alpha, height)\n err[2] = d3 - self.base_length\n step_alpha[0] = err[2] * self.ke * step_alpha_base\n\n if abs(err[2]) < self.err_limit:\n\n # Trovatas la soluzione\n self.alpha = list(alpha)\n return True\n\n # NEXT j!!!\n break\n\n # Next i!!!\n break","def indices_and_currents_TSC_2D( charge_electron, positions_x, positions_y, velocity_x, velocity_y,\\\n x_grid, y_grid, ghost_cells, length_domain_x, length_domain_y, dt ):\n \n \n positions_x_new = positions_x + velocity_x * dt\n positions_y_new = positions_y + velocity_y * dt\n\n base_indices_x = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\n base_indices_y = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\n\n dx = af.sum(x_grid[1] - x_grid[0])\n dy = af.sum(y_grid[1] - y_grid[0])\n\n\n # Computing S0_x and S0_y\n ###########################################################################################\n \n # Determining the grid cells containing the respective particles\n \n x_zone = (((af.abs(positions_x - af.sum(x_grid[0])))/dx).as_type(af.Dtype.u32))\n y_zone = (((af.abs(positions_y - af.sum(y_grid[0])))/dy).as_type(af.Dtype.u32))\n\n \n # Determing the indices of the closest grid node in x direction\n\n temp = af.where(af.abs(positions_x-x_grid[x_zone]) < \\\n af.abs(positions_x-x_grid[x_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_x[temp] = x_zone[temp]\n\n temp = af.where(af.abs(positions_x - x_grid[x_zone]) >= \\\n af.abs(positions_x-x_grid[x_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_x[temp] = (x_zone[temp] + 1).as_type(af.Dtype.u32) \n\n\n # Determing the indices of the closest grid node in y direction\n\n temp = af.where(af.abs(positions_y-y_grid[y_zone]) < \\\n af.abs(positions_y-y_grid[y_zone + 1])\\\n )\n\n if(temp.elements()>0):\n base_indices_y[temp] = y_zone[temp]\n\n temp = af.where(af.abs(positions_y - y_grid[y_zone])>=af.abs(positions_y-x_grid[y_zone + 1]))\n\n if(temp.elements()>0):\n base_indices_y[temp] = (y_zone[temp] + 1).as_type(af.Dtype.u32) \n\n # Concatenating the index list for near by grid nodes in x direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n\n base_indices_minus_two = (base_indices_x - 2).as_type(af.Dtype.u32) \n base_indices_minus = (base_indices_x - 1).as_type(af.Dtype.u32) \n base_indices_plus = (base_indices_x + 1).as_type(af.Dtype.u32) \n base_indices_plus_two = (base_indices_x + 2).as_type(af.Dtype.u32) \n\n\n\n index_list_x = af.join( 1,\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_x),\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\n )\n\n\n\n # Concatenating the index list for near by grid nodes in y direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n \n base_indices_minus_two = (base_indices_y - 2).as_type(af.Dtype.u32) \n base_indices_minus = (base_indices_y - 1).as_type(af.Dtype.u32) \n base_indices_plus = (base_indices_y + 1).as_type(af.Dtype.u32) \n base_indices_plus_two = (base_indices_y + 2).as_type(af.Dtype.u32) \n\n\n index_list_y = af.join( 1,\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_y),\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\n )\n\n # Concatenating the positions_x for determining weights for near by grid nodes in y direction\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\n\n positions_x_5x = af.join( 0,\\\n af.join(0, positions_x, positions_x, positions_x),\\\n af.join(0, positions_x, positions_x),\\\n )\n\n positions_y_5x = af.join( 0,\\\n af.join(0, positions_y, positions_y, positions_y),\\\n af.join(0, positions_y, positions_y),\\\n )\n\n\n\n\n # Determining S0 for positions at t = n * dt\n\n\n distance_nodes_x = x_grid[af.flat(index_list_x)]\n\n distance_nodes_y = y_grid[af.flat(index_list_y)]\n\n\n W_x = 0 * distance_nodes_x.copy()\n W_y = 0 * distance_nodes_y.copy()\n\n\n # Determining weights in x direction\n\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x) < (0.5*dx) )\n\n if(temp.elements()>0):\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx)**2\n\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x) >= (0.5*dx) )\\\n * (af.abs(distance_nodes_x - positions_x_5x) < (1.5 * dx) )\\\n )\n\n if(temp.elements()>0):\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx))**2\n\n\n\n # Determining weights in y direction\n\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x) < (0.5*dy) )\n\n if(temp.elements()>0):\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy)**2\n\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x) >= (0.5*dy) )\\\n * (af.abs(distance_nodes_y - positions_y_5x) < (1.5 * dy) )\\\n )\n\n if(temp.elements()>0):\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy))**2\n\n # Restructering W_x and W_y for visualization and ease of understanding\n\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\n W_y = af.data.moddims(W_y, positions_y.elements(), 5)\n\n # Tiling the S0_x and S0_y for the 25 indices around the particle\n \n S0_x = af.tile(W_x, 1, 1, 5)\n S0_y = af.tile(W_y, 1, 1, 5)\n\n\n S0_y = af.reorder(S0_y, 0, 2, 1)\n\n\n\n #Computing S1_x and S1_y\n ###########################################################################################\n\n positions_x_5x_new = af.join( 0,\\\n af.join(0, positions_x_new, positions_x_new, positions_x_new),\\\n af.join(0, positions_x_new, positions_x_new),\\\n )\n\n positions_y_5x_new = af.join( 0,\\\n af.join(0, positions_y_new, positions_y_new, positions_y_new),\\\n af.join(0, positions_y_new, positions_y_new),\\\n )\n\n\n\n\n # Determining S0 for positions at t = n * dt\n\n W_x = 0 * distance_nodes_x.copy()\n W_y = 0 * distance_nodes_y.copy()\n\n\n # Determining weights in x direction\n\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x_new) < (0.5*dx) )\n\n if(temp.elements()>0):\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x_new[temp])/dx)**2\n\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x_new) >= (0.5*dx) )\\\n * (af.abs(distance_nodes_x - positions_x_5x_new) < (1.5 * dx) )\\\n )\n\n if(temp.elements()>0):\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] \\\n - positions_x_5x_new[temp])/dx\\\n )\\\n )**2\n\n\n\n # Determining weights in y direction\n\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x_new) < (0.5*dy) )\n\n if(temp.elements()>0):\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] \\\n - positions_y_5x_new[temp]\\\n )/dy\\\n )**2\n\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x_new) >= (0.5*dy) )\\\n * (af.abs(distance_nodes_y - positions_y_5x_new) < (1.5 * dy) )\\\n )\n\n if(temp.elements()>0):\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] \\\n - positions_y_5x_new[temp])/dy\\\n )\\\n )**2\n\n # Restructering W_x and W_y for visualization and ease of understanding\n\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\n W_y = af.data.moddims(W_y, positions_x.elements(), 5)\n\n # Tiling the S0_x and S0_y for the 25 indices around the particle \n \n S1_x = af.tile(W_x, 1, 1, 5)\n S1_y = af.tile(W_y, 1, 1, 5)\n\n S1_y = af.reorder(S1_y, 0, 2, 1)\n\n\n ###########################################################################################\n\n # Determining the final weight matrix for currents in 3D matrix form factor\n\n\n W_x = (S1_x - S0_x) * (S0_y + (0.5 *(S1_y - S0_y)) )\n\n\n W_y = (S1_y - S0_y) * (S0_x + (0.5 *(S1_x - S0_x)) )\n\n\n ###########################################################################################\n\n\n # Assigning Jx and Jy according to Esirkepov's scheme\n\n Jx = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\n Jy = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\n\n\n Jx[:, 0, :] = -1 * charge_electron * (dx/dt) * W_x[:, 0, :].copy()\n Jx[:, 1, :] = Jx[:, 0, :] + -1 * charge_electron * (dx/dt) * W_x[:, 1, :].copy()\n Jx[:, 2, :] = Jx[:, 1, :] + -1 * charge_electron * (dx/dt) * W_x[:, 2, :].copy()\n Jx[:, 3, :] = Jx[:, 2, :] + -1 * charge_electron * (dx/dt) * W_x[:, 3, :].copy()\n Jx[:, 4, :] = Jx[:, 3, :] + -1 * charge_electron * (dx/dt) * W_x[:, 4, :].copy()\n \n # Computing current density using currents\n \n Jx = (1/(dx * dy)) * Jx\n\n\n Jy[:, :, 0] = -1 * charge_electron * (dy/dt) * W_y[:, :, 0].copy()\n Jy[:, :, 1] = Jy[:, :, 0] + -1 * charge_electron * (dy/dt) * W_y[:, :, 1].copy()\n Jy[:, :, 2] = Jy[:, :, 1] + -1 * charge_electron * (dy/dt) * W_y[:, :, 2].copy()\n Jy[:, :, 3] = Jy[:, :, 2] + -1 * charge_electron * (dy/dt) * W_y[:, :, 3].copy()\n Jy[:, :, 4] = Jy[:, :, 3] + -1 * charge_electron * (dy/dt) * W_y[:, :, 4].copy()\n \n # Computing current density using currents\n\n Jy = (1/(dx * dy)) * Jy\n\n # Preparing the final index and current vectors\n ###########################################################################################\n \n \n # Determining the x indices for charge deposition\n index_list_x_Jx = af.flat(af.tile(index_list_x, 1, 1, 5))\n\n # Determining the y indices for charge deposition\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\n index_list_y_Jx = af.flat(af.reorder(y_current_zone, 0, 2, 1))\n\n\n currents_Jx = af.flat(Jx)\n\n # Determining the x indices for charge deposition\n index_list_x_Jy = af.flat(af.tile(index_list_x, 1, 1, 5))\n\n # Determining the y indices for charge deposition\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\n index_list_y_Jy = af.flat(af.reorder(y_current_zone, 0, 2, 1))\n \n # Flattenning the Currents array\n currents_Jy = af.flat(Jy)\n\n af.eval(index_list_x_Jx, index_list_y_Jx)\n af.eval(index_list_x_Jy, index_list_y_Jy)\n af.eval(currents_Jx, currents_Jy)\n\n\n return index_list_x_Jx, index_list_y_Jx, currents_Jx,\\\n index_list_x_Jy, index_list_y_Jy, currents_Jy","def test_MagmOcGJ1132b():\n # Remove old log file\n subprocess.run(['rm', 'GJ1132.log'], cwd=cwd)\n # Run vplanet\n subprocess.run(['../../vplanet', 'vpl.in', '-q'], cwd=cwd)\n\n # Grab the output\n output = GetOutput(path=cwd)\n\n # Primary Variables: GJ1132b -- checks MagmOc parameters\n assert np.isclose(output.log.final.GJ1132b.PotTemp, 3358.229436)\n assert np.isclose(output.log.final.GJ1132b.SurfTemp, 4000.000000)\n assert np.isclose(output.log.final.GJ1132b.SolidRadius, 0.750604)\n assert np.isclose(output.log.final.GJ1132b.WaterMassMOAtm, 99.456333)\n assert np.isclose(output.log.final.GJ1132b.WaterMassSol, 0.174876)\n assert np.isclose(output.log.final.GJ1132b.OxygenMassMOAtm, 3.946430e+18)\n assert np.isclose(output.log.final.GJ1132b.OxygenMassSol, 4.449172e+17)\n assert np.isclose(output.log.final.GJ1132b.HydrogenMassSpace, 5.736131e+19)\n assert np.isclose(output.log.final.GJ1132b.OxygenMassSpace, 4.508558e+20)\n assert np.isclose(output.log.final.GJ1132b.CO2MassMOAtm, 1.748940e-296)\n assert np.isclose(output.log.final.GJ1132b.CO2MassSol, 1.748940e-296)","def trap_depth(V,X,Y,Z,Im,Jm,Km): \n from project_parameters import debug,scale,position\n #from all_functions import sum_of_e_field,spher_harm_bas,spher_harm_exp,spher_harm_cmp,find_saddle\n def a(a,N):\n \"\"\"Shortcut function to convert array x into a row vector.\"\"\" \n a=np.ravel(a, order='F') # Same order\n return a\n N1,N2,N3=V.shape\n N=N1*N2*N3\n [Ex,Ey,Ez]=np.gradient(V,abs(X[1]-X[0])/scale,abs(Y[1]-Y[0])/scale,abs(Z[1]-Z[0])/scale)\n E=np.sqrt(Ex**2+Ey**2+Ez**2)\n # identify the escape position and height by checking each point\n minElectricField=np.max(E) # initialize as maximum E field magnitude\n distance=0\n escapeHeight=1\n escapePosition=[0,0,0]\n [Im,Jm,Km] = find_saddle(V,X,Y,Z,3)\n Vm = V[Im,Jm,Km]\n for i in range(N1):\n for j in range(N2):\n for k in range(N3):\n if E[i,j,k]<minElectricField:\n distance=abs(np.sqrt((Im-i)**2+(Jm-j)**2+(Km-k)**2)) \n if distance > 6:\n minElectricField=E[i,j,k]\n escapeHeight=V[i,j,k]\n escapePosition=[i,j,k]\n if debug.trap_depth: \n print E[i,j,k],V[i,j,k],[i,j,k],distance\n check=1 \n if debug.trap_depth: \n print minElectricField,escapeHeight,escapePosition,distance \n if distance<check:\n print('trap_depth.py: Escape point too close to trap minimum. Improve grid resolution or extend grid.')\n if escapeHeight>0.2:\n print('trap_depth.py: Escape point parameter too high. Improve grid resolution or extend grid.')\n D=escapeHeight-Vm\n [Ie,Je,Ke]=escapePosition\n [Xe,Ye,Ze]=[X[Ie],Y[Je],Z[Ke]] \n return [D,Xe,Ye,Ze]","def beam_positions(closepack=False):\n \n x_pos, y_pos = [], []\n\n x=0\n for j in range(0,6,1):\n x += 0.1\n y=0\n for k in range(0,6,2):\n y += 0.2\n x_pos.append(x+(0.05 if closepack else 0))\n y_pos.append(y)\n y += 0.2\n x_pos.append(x)\n y_pos.append(y)\n\n return x_pos, y_pos","def field_at(sources, location):\n vector = polar_to_cart(sources[0].detect(location))\n for source in sources[1:]:\n vector = np.add(vector, polar_to_cart(source.detect(location)))\n return vector","def fix_sphere_h (center_x, center_y, center_z, radius, centers, radii, len_points, list_of_a):\n g_x = []\n g_y = []\n g_z = []\n points = [hydrogen_coord_gen(center_x, center_y, center_z, radius) for i in range(0, len_points)] \n x = [points[i][0] for i in range(0, len(points))] \n y = [points[i][1] for i in range(0, len(points))]\n z = [points[i][2] for i in range(0, len(points))]\n for i in range(0, len(points)):\n check = 0\n check_b = 0\n j = 0\n while (j <= (len(centers) - 1) and (check == 0)): \n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], centers[j][0], centers[j][1], centers[j][2]) < radii[j]):\n check += 1\n j += 1\n h = 0\n while ((check_b == 0) and (h <= len(list_of_a) -1)):\n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], list_of_a[h].x, list_of_a[h].y, list_of_a[h].z) <= 1.50): \n check_b += 1\n h += 1\n if ((check == 0) and (check_b == 0)):\n g_x.append(x[i])\n g_y.append(y[i])\n g_z.append(z[i])\n return g_x, g_y, g_z","def bomb_vector(self):\n\n\t\tif self.b_offset == 0:\n\t\t\top = sin\n\t\telse:\n\t\t\top = cos\n\n\t\tself.y -= self.speed\n\t\tself.rect.y = self.y\n\t\t# MMMMMMMMMMMMMMMMMMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATHS\n\t\tself.x = int((self.g_settings.screen_height/2) + self.amplitude*op(self.frequency*((float(self.y)/self.g_settings.screen_width)*(2*pi) + (self.speed*time()))))\n\t\tif self.b_offset == 0:\n\t\t\tself.rect.x = self.x + self.position_x - 16\n\t\telif self.b_offset == 1:\n\t\t\tself.rect.x = self.x + self.position_x + 16\n\t\tself.screen.blit(self.image, self.rect)","def approach_gps(g_lat,g_lon,emily_lat_start, emily_lon_start, pose_rad, Parameters): #approach a gps position using potential fields\r\n\tx_goal,y_goal = latlongtoxy(g_lat,g_lon,g_lat)\r\n\tx_e_start,y_e_start = latlongtoxy(emily_lat_start,emily_lon_start,g_lat)\r\n\r\n\tprint (\"\\n HERE I AM\\n\\n\")\r\n\r\n\tdist = haver_distance(g_lat, g_lon, emily_lat_start, emily_lon_start)\r\n\tinitial_dist = dist\r\n\r\n\tprint ('Distance: ',dist)\r\n\theading = get_heading(emily_lat_start, emily_lon_start, g_lat, g_lon)\r\n print ('After get heading')\r\n\t# Eric: I'm not sure if turn_towards is necessary for a successful run.\r\n\t#turn_towards(heading)\r\n\tprint ('After Turn towards')\r\n\t#turn towards the goal initially\r\n\r\n\tstart_time = time.time()\r\n\tcurrent_time = 0\r\n\tdstore = []\r\n\thstore = []\r\n\twhile(dist >= goal_radius):\r\n\r\n\t\t#------------ code for reading gps location of emily and its orientation ------\r\n\t\te_lat = vehicle.location.global_frame.lat\r\n\t\te_lon = vehicle.location.global_frame.lon\r\n\t\te_heading = vehicle.heading * pi/180\t\t# convert heading to radians\r\n\t\t#------------------ get e_lat,e_lon, e_orient ---------------------\r\n\r\n\r\n\t\tx_e,y_e = latlongtoxy(e_lat,e_lon,g_lat)\t\t\t#change latitude and longitude to xy\r\n\r\n\t\t#x,y are given to approach victim function as y,x to algin the north heading and direction in x,y\r\n\r\n\t\tdx,dy = approach_victim_behaviour(y_goal,x_goal, y_e,x_e, pose_rad, Parameters)\t#get potential field vector\r\n\t\trc1, rc3 = dxdytorc(dx,dy, e_heading,g_lon)\t\t\t\t\t#get rc parameters\r\n\t\tdist = haver_distance(g_lat, g_lon, e_lat, e_lon)\t\t\t\t#haversine distance\r\n\r\n\t\tcurrent_time = time.time() - start_time\r\n\t\tprint (\"Time, Heading, Distance\")\r\n\t\tprint (current_time, e_heading*180/pi, dist)\r\n\t\tdstore.append(dist)\r\n\t\thstore.append(e_heading*180/pi)\r\n\t\t#code for sending the writing the rc commands\r\n\t\t# 3 is the thrust control\r\n\t\t#vehicle.channels.overrides = {'3':rc3}\r\n\t\tsendThrottleCommand(rc3, enableThrottle)\r\n\t\ttime.sleep(0.5)\r\n\t\tvehicle.channels.overrides = {'1':rc1}\r\n\t\tprint (\"Rudder: \",rc1)\r\n\t\tprint (\"Throttle: \",rc3)\r\n\t\tsaveToLog(e_lat, e_lon,dist,rc1,rc3)\r\n\t\ttime.sleep(0.5)\r\n\tprint(initial_dist)\r\n\tprint(\"intial \", emily_lat_start,emily_lon_start)\r\n\tprint(\"final \",e_lat,e_lon)\r\n\tplt.plot(dstore)\r\n\t#plt.title('Distance form home vs time')\r\n\tplt.xlabel(\"Time\")\r\n\tplt.ylabel('Distance')\r\n\tplt.show()\r\n\tplt.plot(hstore)\r\n\tplt.show()","def preprocess(self):\n\n mm_magcoord.add_aacgm_coordinates(self)\n mm_magcoord.add_quasi_dipole_coordinates(self)\n mm_sc.calculate_ecef_velocity(self)\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\n\n return","def get_fan_in(xy=(0, 0), dim_x_l=10, dim_y_l=10, dim_x_u=9, dim_y_u=9, block_x=2, block_y=2, radius=2):\n x = xy[0]\n y = xy[1]\n if dim_x_u > 1:\n factor_x = ((dim_x_l-1)-(block_x-1))/(1.0*(dim_x_u-1))\n else:\n factor_x = ((dim_x_l-1)-(block_x))/2.0\n if dim_y_u > 1:\n factor_y = ((dim_y_l-1)-(block_y-1))/(1.0*(dim_y_u-1))\n else:\n factor_y = ((dim_y_l-1)-(block_y))/2.0\n results = []\n if dim_x_u > 1 and dim_y_u > 1:\n for xx in range(block_x):\n for yy in range(block_y):\n if (xx-(block_x-1)*0.5)**2 + (yy-(block_y-1)*0.5)**2 > radius**2:\n continue\n results.append((int((factor_x*(x))+xx), int((factor_y*(y))+yy)))\n return results\n elif dim_x_u == 1 and dim_y_u > 1:\n for xx in range(block_x):\n for yy in range(block_y):\n if (xx-(block_x-1)*0.5)**2 + (yy-(block_y-1)*0.5)**2 > radius**2:\n continue\n results.append((int((dim_x_l-block_x)/2.0+xx), int((factor_y*(y)+yy))))\n return results\n elif dim_x_u > 1 and dim_y_u == 1:\n for xx in range(block_x):\n for yy in range(block_y):\n if (xx-(block_x-1)*0.5)**2 + (yy-(block_y-1)*0.5)**2 > radius**2:\n continue\n results.append((int((factor_x*(x)+xx)), int((dim_y_l-block_y)/2.0+yy)))\n return results\n elif dim_x_u == 1 and dim_y_u == 1:\n for xx in range(block_x):\n for yy in range(block_y):\n if (xx-(block_x-1)*0.5)**2 + (yy-(block_y-1)*0.5)**2 > radius**2:\n continue\n results.append((int((dim_x_l-block_x)/2.0+xx), int((dim_y_l-block_y)/2.0+yy)))\n return results","def get_bforce_wm_ws_Gx_surf(self):\n\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w'] \n \n self.Gm1 = np.zeros([Ly])\n self.dGm1_dS = np.zeros([Ly]) \n self.Gt1 = np.zeros([Ly])\n self.dGt1_dS = np.zeros([Ly]) \n self.Bfsfc_bl = np.zeros([Ly])\n self.Av_bl = np.zeros([Ly])\n self.dAv_bl = np.zeros([Ly])\n \n #debugging\n self.wm_surf = np.zeros([Ly])\n self.ws_surf = np.zeros([Ly]) \n\n #---> j-loop\n for j in range(Ly): \n k_w = self.kbl[j] # KBL is \"new bl index after calling find_new_kbl()\n z_bl = z_u_w[j,N] - self.hbls[j]\n zscale = self.hbls[j] \n \n if self.swr_frac[j,k_w-1] > 0:\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\n \n else:\n Bfsfc = self.Bo[j] + self.Bosol[j]\n \n # CALCUALTE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm_surf[j] = wm\n self.ws_surf[j] = ws \n\n if self.LIMIT_UNSTABLE_ONLY:\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\n else:\n f1 = 0\n\n \n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\n cff_up = cff * (z_bl - z_u_w[j,k_w])\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\n\n #MOMENTUM \n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\n self.Av_bl[j] = Av_bl\n self.dAv_bl[j] = dAv_bl\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \n\n #TEMPERATURE(BUOYANCY)\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \n\n self.Bfsfc_bl[j] = Bfsfc","def getMagneticField(self, z):\n return float(self.solenoid.B_interp(z))","def get_observations(self):\n joint_states = self.joints_state\n self.force = self.wrench_stamped.wrench.force\n self.torque = self.wrench_stamped.wrench.torque\n self.static_taxel = self.tactile_static.taxels\n# dynamic_taxel= tactile_dynamic\n\n# print(\"[force]\", self.force.x, self.force.y, self.force.z)\n# print(\"[torque]\", self.torque.x, self.torque.y, self.torque.z)\n shp_joint_ang = joint_states.position[0]\n shl_joint_ang = joint_states.position[1]\n elb_joint_ang = joint_states.position[2]\n wr1_joint_ang = joint_states.position[3]\n wr2_joint_ang = joint_states.position[4]\n wr3_joint_ang = joint_states.position[5]\n\n shp_joint_vel = joint_states.velocity[0]\n shl_joint_vel = joint_states.velocity[1]\n elb_joint_vel = joint_states.velocity[2]\n wr1_joint_vel = joint_states.velocity[3]\n wr2_joint_vel = joint_states.velocity[4]\n wr3_joint_vel = joint_states.velocity[5]\n\n q = [shp_joint_ang, shl_joint_ang, elb_joint_ang, wr1_joint_ang, wr2_joint_ang, wr3_joint_ang]\n# print(\"q(observation):\", q)\n eef_x, eef_y, eef_z = self.get_xyz(q)\n self.end_effector = self.get_xyz(q)\n eef_x_ini, eef_y_ini, eef_z_ini = self.get_xyz(self.init_joint_pose2) \n\n delta_image_r, delta_image_l = self.get_image()\n self.cnn_image_r = agent.update_cnn(delta_image_r)\n self.cnn_image_l = agent.update_cnn(delta_image_l)\n self.cnn_image_r_list = self.cnn_image_r.tolist()\n self.cnn_image_l_list = self.cnn_image_l.tolist()\n print(\"r_list\", self.cnn_image_r_list)\n print(\"l_list\", self.cnn_image_l_list)\n\n observation = []\n# rospy.logdebug(\"List of Observations==>\"+str(self.observations))\n for obs_name in self.observations:\n if obs_name == \"shp_joint_ang\":\n observation.append((shp_joint_ang - self.init_joint_pose2[0]) * self.joint_n)\n elif obs_name == \"shl_joint_ang\":\n observation.append((shl_joint_ang - self.init_joint_pose2[1]) * self.joint_n)\n elif obs_name == \"elb_joint_ang\":\n observation.append((elb_joint_ang - self.init_joint_pose2[2]) * self.joint_n)\n elif obs_name == \"wr1_joint_ang\":\n observation.append((wr1_joint_ang - self.init_joint_pose2[3]) * self.joint_n)\n elif obs_name == \"wr2_joint_ang\":\n observation.append((wr2_joint_ang - self.init_joint_pose2[4]) * self.joint_n)\n elif obs_name == \"wr3_joint_ang\":\n observation.append((wr3_joint_ang - self.init_joint_pose2[5]) * self.joint_n)\n elif obs_name == \"shp_joint_vel\":\n observation.append(shp_joint_vel)\n elif obs_name == \"shl_joint_vel\":\n observation.append(shl_joint_vel)\n elif obs_name == \"elb_joint_vel\":\n observation.append(elb_joint_vel)\n elif obs_name == \"wr1_joint_vel\":\n observation.append(wr1_joint_vel)\n elif obs_name == \"wr2_joint_vel\":\n observation.append(wr2_joint_vel)\n elif obs_name == \"wr3_joint_vel\":\n observation.append(wr3_joint_vel)\n elif obs_name == \"eef_x\":\n observation.append((eef_x - eef_x_ini) * self.eef_n)\n elif obs_name == \"eef_y\":\n observation.append((eef_y - eef_y_ini) * self.eef_n)\n elif obs_name == \"eef_z\":\n observation.append((eef_z - eef_z_ini) * self.eef_n)\n elif obs_name == \"force_x\":\n observation.append((self.force.x - self.force_ini.x) / self.force_limit1 * self.force_n)\n elif obs_name == \"force_y\":\n observation.append((self.force.y - self.force_ini.y) / self.force_limit1 * self.force_n)\n elif obs_name == \"force_z\":\n observation.append((self.force.z - self.force_ini.z) / self.force_limit1 * self.force_n)\n elif obs_name == \"torque_x\":\n observation.append((self.torque.x - self.torque_ini.x) / self.torque_limit1 * self.torque_n)\n elif obs_name == \"torque_y\":\n observation.append((self.torque.y - self.torque_ini.y) / self.torque_limit1 * self.torque_n)\n elif obs_name == \"torque_z\":\n observation.append((self.torque.z - self.torque_ini.z) / self.torque_limit1 * self.torque_n)\n elif obs_name == \"image_cnn\":\n for x in range(0, 10):\n observation.append(self.cnn_image_r_list[0][x])\n# print(\"r_list\", self.cnn_image_r_list[0][x])\n for x in range(0, 10):\n observation.append(self.cnn_image_l_list[0][x])\n# print(\"l_list\", self.cnn_image_l_list[0][x])\n elif obs_name == \"static_taxel\":\n for x in range(0, 28):\n observation.append((self.static_taxel[0].values[x] - self.static_taxel_ini[0].values[x]) * self.taxel_n)\n for x in range(0, 28):\n observation.append((self.static_taxel[1].values[x] - self.static_taxel_ini[1].values[x]) * self.taxel_n)\n# elif obs_name == \"dynamic_taxel\":\n# observation.append(dynamic_taxel[0].values) * self.taxel_n\n# observation.append(dynamic_taxel[1].values) * self.taxel_n\n else:\n raise NameError('Observation Asked does not exist=='+str(obs_name))\n\n print(\"observation\", list(map(round, observation, [3]*len(observation))))\n# print(\"observation\", observation)\n\n return observation","def compute_magnetic_field(self, coords, params=None, basis=\"rpz\"):\n if params is None:\n params = [None] * len(self._fields)\n if isinstance(params, dict):\n params = [params]\n B = 0\n for i, field in enumerate(self._fields):\n B += field.compute_magnetic_field(coords, params[i % len(params)], basis)\n return B","def fglidingHST_exact(xy, v, NL, KL, BM, Mm, params):\n I1 = params['I1']\n I3 = params['I3']\n l = params['l']\n g = params['g']\n k = params['k']\n\n try:\n NP, NN = np.shape(NL)\n except:\n '''There is only one particle'''\n NP = 1\n NN = 0\n\n # print 'xy = ', xy\n # print 'v = ', v\n\n x = xy[:, 0].ravel() # .reshape(NP,1);\n y = xy[:, 1].ravel() # .reshape(NP,1);\n theta = xy[:, 2].ravel() # .reshape(NP,1);\n phi = xy[:, 3].ravel() # .reshape(NP,1);\n psi = xy[:, 4].ravel() # .reshape(NP,1);\n vx = v[:, 0].ravel() # .reshape(NP,1);\n vy = v[:, 1].ravel() # .reshape(NP,1);\n vtheta = v[:, 2].ravel() # .reshape(NP,1);\n vphi = v[:, 3].ravel() # .reshape(NP,1);\n vpsi = v[:, 4].ravel() # .reshape(NP,1)\n\n # if theta is very nearly pi, push it back\n close_pi = 3.1415\n # xout[xy[:,2] > close_pi,2] = close_pi\n theta[theta > close_pi] = close_pi\n\n # w3 = vpsi + vphi*np.cos(theta)\n w3 = params['w3']\n # if not isinstance(w3,np.ndarray):\n # print 'w3 --> ndarray'\n # w3 = np.array(w3)\n\n # SPRING FORCE\n vecx = np.array([[KL[i, j] * (xy[i, 0] - xy[NL[i, j], 0]) for j in range(NN)] for i in range(NP)])\n vecy = np.array([[KL[i, j] * (xy[i, 1] - xy[NL[i, j], 1]) for j in range(NN)] for i in range(NP)])\n mag = np.sqrt(vecx ** 2 + vecy ** 2)\n # KLnoz = KL.copy() #no zeros\n # KLnoz[KLnoz ==0] = 1. #same value as mag[mag==0], so that stretch=0 for those\n stretch = mag - BM\n mag[mag == 0.] = 1. # avoid divide by zero error\n # print(stretch)\n springx = k * np.sum(stretch * vecx / mag, axis=-1)\n springy = k * np.sum(stretch * vecy / mag, axis=-1)\n # print 'stretch = ', stretch\n\n # add them up\n FX = - springx.ravel() # .reshape(NP,1)\n FY = - springy.ravel() # .reshape(NP,1)\n\n # Set force on fixed particles to zero\n if 'BIND' in params:\n if len(params['BIND']) > 0:\n FX[params['BIND']] = 0.\n FY[params['BIND']] = 0.\n\n # Transform into A frame\n Fx = FX * np.cos(phi) + FY * np.sin(phi)\n Fy = -FX * np.sin(phi) + FY * np.cos(phi)\n\n # print '\\n Fx =', Fx\n\n # VERTICAL REACTION FORCE\n # print 'T1 = ', Mm*g*I1\n # print 'T2 =', - Mm*l*(I1*np.cos(theta)*(vtheta**2 + vphi**2*np.sin(theta)**2))\n # print 'T3a = ', I3*w3\n # print 'T3b = ', vphi*np.sin(theta)**2\n # print 'T3 = ', I3*w3*vphi*np.sin(theta)**2\n # print 'T4 = ', - l* np.sin(theta)*np.cos(theta)*Fx\n # print 'denom = ', I1 + Mm*l**2*np.sin(theta)**2\n gn = (Mm * g * I1 - Mm * l * (I1 * np.cos(theta) * (vtheta ** 2 + vphi ** 2 * np.sin(theta) ** 2) - \\\n I3 * w3 * vphi * (np.sin(theta) ** 2) - l * np.sin(theta) * np.cos(theta) * Fx)) / (\n I1 + Mm * l ** 2 * np.sin(theta) ** 2)\n\n # print 'gn_ term 1 = ', Mm*g*I1\n # print 'gn_ denominator = ', (I1 + Mm*l**2*np.sin(theta)**2)\n # print 'gn_ denom term 2 = ', Mm*l**2\n print 'gn_exact = ', gn\n # print 'gn = ', gn\n\n # EULER EQUATIONS\n # print 'denominator = ',I1*np.sin(theta)\n dvphi = (I3 * w3 * vtheta - 2 * I1 * vphi * vtheta * np.cos(theta) - l * Fy) / (I1 * np.sin(theta))\n # print 'dvtheta -- term 1:', l*gn[4]*np.sin(theta[4])\n # print 'dvtheta -- term 2:', -l*Fx[4]*np.cos(theta[4])\n # print 'dvtheta -- term 3:', I1*vphi[4]**2*np.sin(theta[4])*np.cos(theta[4])\n # print 'dvtheta -- term 4:', I3*w3[4]*vphi[4]*np.sin(theta[4])\n dvtheta = (1. / I1) * (l * gn * np.sin(theta) - l * Fx * np.cos(theta) + I1 * vphi ** 2 * np.sin(theta) * np.cos(\n theta) - I3 * w3 * vphi * np.sin(theta))\n dvpsi = - dvphi * np.cos(theta) + vphi * np.sin(theta) * vtheta\n\n # print 'shape(dvphi)=', np.shape(dvphi)\n # print 'shape(Fx)=', np.shape(Fx)\n\n # SPRING EQUATIONS\n # print 'dvtheta =', dvtheta\n wx = l * (dvtheta * np.cos(theta) - vtheta ** 2 * np.sin(theta) - vphi ** 2 * np.sin(theta))\n wy = l * (dvphi * np.sin(theta) + 2 * vphi * vtheta * np.cos(theta))\n wX = wx * np.cos(phi) - wy * np.sin(phi)\n wY = wx * np.sin(phi) + wy * np.cos(phi)\n dvX = (FX / Mm) - wX\n dvY = (FY / Mm) - wY\n\n # print 'shapes = ', np.shape(dvX), np.shape(dvY),np.shape(dvtheta),np.shape(dvphi),np.shape(dvpsi)\n ftx = np.dstack((dvX, dvY, dvtheta, dvphi, dvpsi))[0]\n # print 'Resulting second derivative: ', ftx[1,:]\n\n if 'BIND' in params:\n if len(params['BIND']) > 0:\n ftx[params['BIND'], 0:2] = [0., 0.]\n # ftx[params['BIND']] = [0.,0.,0.,0.,0.]\n\n # print 'ftx = ', ftx[4,:]\n # gn_check = Mm*g - Mm*l*(dvtheta*np.sin(theta) + vtheta**2*np.cos(theta))\n # print 'gn_check = ', gn_check-gn\n # if sum(abs(gn_check -gn)) > 1e-8:\n # print 'gn vertical reaction force does not match up!'\n # print 'gn_check - gn = ', gn_check-gn\n print 'ftx = ', ftx\n\n return ftx","def sunpos_mag(t,lat,lon,elev,gm,temp=None,press=None,radians=True):\n #az_zen is a (...,5) dimension ndarray\n az_zen = sunpos(t,lat,lon,elev,temp,press,radians=radians)\n decl = declination(lat,lon,elev,t,gm,radians)\n az_zen[...,0] -= decl\n #subtract declination to go from true N to magnetic N\n return az_zen","def fix_sphere_m (center_x, center_y, center_z, radius, centers, radii, len_points):\n \n g_x = []\n g_y = []\n g_z = []\n points = [hydrogen_coord_gen(center_x, center_y, center_z, radius) for i in range(0, len_points)] \n x = [points[i][0] for i in range(0, len(points))] \n y = [points[i][1] for i in range(0, len(points))]\n z = [points[i][2] for i in range(0, len(points))]\n\n for i in range(0, len(points)):\n check = 0\n j = 0\n while (j <= (len(centers) - 1) and (check == 0)): \n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], centers[j][0], centers[j][1], centers[j][2]) < radii[j]):\n check += 1\n j += 1\n if (check == 0):\n g_x.append(x[i])\n g_y.append(y[i])\n g_z.append(z[i])\n\n return g_x, g_y, g_z","def photons(self, depth=1):\n self.dx[:,:self.W-1] = self.z[:,1:] - self.z[:,:self.W-1]\n self.dy[:self.H-1,:] = self.z[1:,:] - self.z[:self.H-1,:]\n px = self.xv - self.dx*depth\n py = self.yv - self.dy*depth\n return px,py","def get_floor_reference_points():\n global Z # This declaration is needed to modify the global variable Z\n global floor_reference_points # Maybe erase.\n global floor_reference_orientations # Maybe erase.\n \n #Z = (-0.04311285564353425 -0.04512672573083166 -0.04080078888404003 -0.046071914959185875)/4\n #Z= -0.04721129960500225\n Z = -0.15113003072395247\n print(Z)\n# [0.5264201148167275, 0.40034933311487086, -0.027560670871152958]\n# Point 1 = [0.5264201148167275, 0.40034933311487086, -0.027560670871152958]\n# Move the LEFT arm to point 2 and press enter.\n# Move the LEFT arm to point 3 and press enter.\n# Point 3 = [0.8164126163781988, 0.00011724257622775782, -0.006060458646583389]\n# Move the LEFT arm to point 4 and press enter.\n# Point 4 = [0.5774338486223564, -0.02912627450728407, -0.02923769860966796]\n# Point 1 = [0.45835412247904794, 0.4167330917312844, -0.11362745036843477]\n# Move the LEFT arm to point 2 and press enter.\n# Point 2 = [0.7046556740624649, 0.45390428836232344, -0.11322759071560898]\n# Move the LEFT arm to point 3 and press enter.\n# Point 3 = [0.7778487250094798, 0.07406413897305184, -0.11181591166991744]\n# Move the LEFT arm to point 4 and press enter.\n# Point 4 = [0.5418466718761972, 0.034360381218309734, -0.11464607923115094]\n\n #return [[p1[0],p1[1]], [p2[0],p2[1]], [p3[0],p3[1]], [p4[0],p4[1]]]\n \n #print p4\n filename = \"/home/sampath/midca/examples/_gazebo_baxter/calibration.txt\"\n f = open(filename, 'r')\n p1 = f.readline().split(' ')\n p2 = f.readline().split(' ')\n p3 = f.readline().split(' ')\n p4 = f.readline().split(' ')\n \n p1[0] = float(p1[0])\n p1[1] = float(p1[1])\n p2[0] = float(p2[0])\n p2[1] = float(p2[1])\n p3[0] = float(p3[0])\n p3[1] = float(p3[1])\n p4[0] = float(p4[0])\n p4[1] = float(p4[1])\n \n return [[p1[0], p1[1]],\n [p2[0], p2[1]],\n [p3[0], p3[1]],\n [p4[0], p4[1]]]","def main():\r\n #Drag Force Equation: 1/2 * rho * Cd * A * v^2\r\n\r\n #User-Defined Constants\r\n global m\r\n global v0\r\n global theta\r\n global rho #Fluid Density\r\n global A #Cross-sectional Area\r\n global Cd #Drag coefficient\r\n global tStep\r\n global g\r\n\r\n m = 1\r\n v0 = 30\r\n theta = math.radians(45)\r\n rho = 1.225\r\n A = 0.05\r\n Cd = 0.5 #A ball is approx. 0.5\r\n tStep = 0.005\r\n g = 9.8\r\n\r\n\r\n #Data Structures\r\n global tHist\r\n global xHist\r\n global yHist\r\n global thetaHist\r\n global vHist\r\n global vXHist\r\n global vYHist\r\n tHist = [] #list for all time steps\r\n xHist = [] #list for all x position steps\r\n yHist = [] #list for all y position steps\r\n thetaHist = [] #List for all theta at every time step\r\n vHist = [] #list for all velocities at every time step\r\n vXHist = [] #list for all x-axis velocities at every time step\r\n vYHist = [] #list for all y-axis velocities at every time step\r\n\r\n #Initialize intial values\r\n tHist.append(0.0)\r\n xHist.append(0.0)\r\n yHist.append(0.0)\r\n thetaHist.append(theta)\r\n vHist.append(v0)\r\n vXHist.append(v0 * math.cos(theta))\r\n vYHist.append(v0 * math.sin(theta))\r\n vTheta = math.atan(vYHist[0] / vXHist[0])\r\n # print(\"t: \" + str(tHist[0]))\r\n # print(\"x: \" + str(xHist[0]))\r\n # print(\"y: \" + str(yHist[0]))\r\n # print(\"v: \" + str(vHist[0]))\r\n # print(\"Vx: \" + str(vXHist[0]))\r\n # print(\"Vy: \" + str(vYHist[0]))\r\n\r\n #Convenience variables\r\n global k\r\n\r\n counter = 1\r\n #Loop until the y-displacement becomes negative (projectile reaches ground again)\r\n while True:\r\n tHist.append(counter * tStep) #increment time\r\n print(\"t: \" + str(tHist[counter]))\r\n\r\n #This large hunk is the solution to the net force differential equation in the x-axis\r\n # oneOverVX = (1/vXHist[counter-1]) + (((rho*A*Cd*math.cos(thetaHist[counter-1]))/(2*m))*(tStep)) #STABLE\r\n # oneOverVX = (1/vXHist[counter-1]) + (((rho*A*Cd)/(2*m))*(tStep))\r\n # oneOverVX = (1/vHist[counter-1]) + (((rho*A*Cd*math.cos(thetaHist[counter-1]))/(2*m))*(tStep))\r\n oneOverVX = (1/vXHist[counter-1]) + ((rho*A*Cd)/(2*m*math.cos(thetaHist[counter-1]))*(tStep)) #This is one over the solution for velocity in the x-axis net force differential equation\r\n vXHist.append(1 / oneOverVX) #Adding the velocity to the list of velocities\r\n\r\n vY0 = vYHist[counter-1] #Convenience variable\r\n # k = 0.5 * rho * A * Cd * math.sin(abs(thetaHist[counter-1])) #STABLE\r\n # k = 0.5 * rho * A * Cd\r\n k = (rho * A * Cd) / (2 * math.sin(abs(thetaHist[counter-1]))) #Convenience variable\r\n print(\"k: \" + str(k))\r\n print(\"vX: \" + str(vXHist[counter]))\r\n rootGMK = math.sqrt(g*m*k) #Convenience variable\r\n if vYHist[counter-1] > 0.0: #If the projectile is going upwards\r\n #Solving the y-axis differential equation for velocity\r\n equationRight = -rootGMK * ((tStep/m) - (math.atan((k*vY0)/(rootGMK))/rootGMK))\r\n vYHist.append((math.tan(equationRight) * rootGMK) / k)\r\n elif vYHist[counter-1] < 0.0: #If the projectile is going downwards\r\n #Solving the y-axis differential equation for velocity\r\n\r\n # Hand-solved integral\r\n # exponent = -(2*tStep*rootGMK)/m\r\n # numerator = g*m*math.exp(exponent) - math.exp(exponent)*vY0*rootGMK - vY0*rootGMK - g*m\r\n # denominator = math.exp(exponent)*(vY0-rootGMK) - vY0*k - rootGMK\r\n # vYHist.append(numerator / denominator)\r\n\r\n #Wolfram Alpha arctanh integral\r\n arctanh =(vY0*math.sqrt(k))/(math.sqrt(g*m))\r\n print(\"arctanh: \" + str(arctanh))\r\n equationRight = (np.arctanh(arctanh))/(rootGMK) - (tStep/m)\r\n vYHist.append(np.tanh(rootGMK * equationRight) * ((math.sqrt(g*m))/(math.sqrt(k))))\r\n else: #If current y velocity is 0\r\n vYHist.append(vY0 - g*tStep)\r\n print(\"vY: \" + str(vYHist[counter]))\r\n\r\n vHist.append(math.hypot(vXHist[counter], vYHist[counter])) #Calculate the net velocity and add it to the velocities list\r\n print(\"v: \" + str(vHist[counter]))\r\n thetaHist.append(math.atan(vYHist[counter]/vXHist[counter])) #Calculate the current angle based on the velocities and add it to the theta list\r\n print(\"0: \" + str(math.degrees(thetaHist[counter])))\r\n\r\n x0 = xHist[counter-1]\r\n y0 = yHist[counter-1]\r\n\r\n # yIntegral = trigintegrate()\r\n\r\n \"\"\"\r\n Note: What I wanted to do here was to integrate the velocity functions over the time interval to find the exact\r\n changes in position. Unfortunately, I was running short of time and decided it was not worth it to move forward with\r\n this final step, and instead worked on the presentation and testing different cases.\r\n \"\"\"\r\n xHist.append(x0 + vXHist[counter]*tStep) #Calculate new x position using x = x0 + vt\r\n yHist.append(y0 + vYHist[counter]*tStep) #Calculate new y position using y = y0 + vt\r\n print(\"x: \" + str(xHist[counter]))\r\n print(\"y: \" + str(yHist[counter]))\r\n print()\r\n\r\n # xHist.append(xHist[counter-1] + vXHist[counter-1]*tStep + 0.5*aXHist[counter-1]*tStep**2)\r\n # yHist.append(yHist[counter-1] + vYHist[counter-1]*tStep + 0.5*aYHist[counter-1]*tStep**2)\r\n # vXHist.append(vXHist[counter-1] + aXHist[counter-1]*tStep)\r\n # vYHist.append(vYHist[counter-1] + aYHist[counter-1]*tStep)\r\n # vHist.append(math.hypot(vXHist[counter], vYHist[counter]))\r\n #\r\n # vTheta = math.atan(vYHist[counter] / vXHist[counter])\r\n # xDragAccel = -0.5*rho*Cd*A*vHist[counter]**2*math.cos(vTheta) / m\r\n # yDragAccel = -math.copysign(0.5*rho*Cd*A*vHist[counter]**2*math.sin(vTheta) / m, vYHist[counter])\r\n #\r\n # aXHist.append(xDragAccel)\r\n # aYHist.append(-g*tStep + yDragAccel)\r\n\r\n if vYHist[counter-1] > 0.0 and vYHist[counter] < 0.0: #Check if the projectile has reached it's peak by checking for a critical point\r\n print(\"max height reached at time=\" + str(tHist[counter]))\r\n # break\r\n\r\n # print(\"t: \" + str(tHist[counter]))\r\n # print(\"x: \" + str(xHist[counter]))\r\n # print(\"y: \" + str(yHist[counter]))\r\n # print(\"Vx: \" + str(vXHist[counter]))\r\n # print(\"Vy: \" + str(vYHist[counter]))\r\n # print(\"Ax: \" + str(aXHist[counter]))\r\n # print(\"Ay: \" + str(aYHist[counter]))\r\n\r\n if yHist[counter] < 0 or counter > 99999: #End the loop if the projectile has reached the ground (or limit the number of iterations to avoid computer death)\r\n break\r\n\r\n counter += 1\r\n\r\n plotData()","def Sphere_ExactSerendipityLagrangeQuad():\n\n mesh = Sphere_CubeToSerendipityLagrangeQuad(1)\n \n ################\n # Modifications for exact sphere\n ################\n # x=+1 side\n def posXvals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.ones(xi1.shape);yb=np.array(-xi1);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n return np.vstack([x,y,z])\n def posXnormals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.ones(xi1.shape);yb=np.array(-xi1);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = -1.0 * xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\n dxdxi2 = 1.0 * xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\n dydxi1 = -1.0 * np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n dydxi2 = 1.0 * yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\n dzdxi1 = -1.0 * zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\n dzdxi2 = 1.0 * np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n magnitude = np.sqrt(np.sum(J**2,axis=1))\n return J.T/magnitude\n def posXJ(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.ones(xi1.shape);yb=np.array(-xi1);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = -1.0 * xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\n dxdxi2 = 1.0 * xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\n dydxi1 = -1.0 * np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n dydxi2 = 1.0 * yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\n dzdxi1 = -1.0 * zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\n dzdxi2 = 1.0 * np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n return np.sqrt(np.sum(J**2,axis=1))\n mesh.eList[0].vals = posXvals\n mesh.eList[0].normals = posXnormals\n mesh.eList[0].J = posXJ\n \n def posYvals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1);yb=np.ones(xi1.shape);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n return np.vstack([x,y,z])\n def posYnormals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1);yb=np.ones(xi1.shape);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\n dydxi2 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n magnitude = np.sqrt(np.sum(J**2,axis=1))\n return J.T/magnitude\n def posYJ(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1);yb=np.ones(xi1.shape);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\n dydxi2 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n return np.sqrt(np.sum(J**2,axis=1))\n mesh.eList[1].vals = posYvals\n mesh.eList[1].normals = posYnormals\n mesh.eList[1].J = posYJ\n \n # x=-1 side\n def negXvals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=-np.ones(xi1.shape);yb=np.array(xi1);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n return np.vstack([x,y,z])\n def negXnormals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=-np.ones(xi1.shape);yb=np.array(xi1);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\n dydxi1 = 1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n dydxi2 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n magnitude = np.sqrt(np.sum(J**2,axis=1))\n return J.T/magnitude\n def negXJ(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=-np.ones(xi1.shape);yb=np.array(xi1);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\n dydxi1 = 1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n dydxi2 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n return np.sqrt(np.sum(J**2,axis=1))\n mesh.eList[2].vals = negXvals\n mesh.eList[2].normals = negXnormals\n mesh.eList[2].J = negXJ\n\n # y=-1 side\n def negYvals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(-xi1);yb=-np.ones(xi1.shape);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2;\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n return np.vstack([x,y,z])\n def negYnormals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(-xi1);yb=-np.ones(xi1.shape);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2; \n dxdxi1 = -1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n dxdxi2 = 1.0*0.5*xb*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5*(-zb+2.0*yy*zb/3.0)\n dydxi1 = -1.0*0.5*yb*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5*(-xb+2.0*xb*zz/3.0)\n dydxi2 = 1.0*0.5*yb*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5*(-zb+2.0*xx*zb/3.0)\n dzdxi1 = -1.0*0.5*zb*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5*(-xb+2.0*xb*yy/3.0)\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0) \n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n magnitude = np.sqrt(np.sum(J**2,axis=1))\n return J.T/magnitude\n def negYJ(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(-xi1);yb=-np.ones(xi1.shape);zb=np.array(xi2);\n xx=xb**2;yy=yb**2;zz=zb**2; \n dxdxi1 = -1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n dxdxi2 = 1.0*0.5*xb*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5*(-zb+2.0*yy*zb/3.0)\n dydxi1 = -1.0*0.5*yb*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5*(-xb+2.0*xb*zz/3.0)\n dydxi2 = 1.0*0.5*yb*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5*(-zb+2.0*xx*zb/3.0)\n dzdxi1 = -1.0*0.5*zb*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5*(-xb+2.0*xb*yy/3.0)\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0) \n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n return np.sqrt(np.sum(J**2,axis=1))\n mesh.eList[3].vals = negYvals\n mesh.eList[3].normals = negYnormals\n mesh.eList[3].J = negYJ\n \n # z=+1 side\n def posZvals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1)\n yb=np.array(-xi2)\n zb=np.ones(xi1.shape)\n xx=xb**2;yy=yb**2;zz=zb**2;\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n return np.vstack([x,y,z])\n def posZnormals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1);yb=np.array(-xi2);zb=np.ones(xi1.shape);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n dxdxi2 = -1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\n dydxi2 = -1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\n dzdxi2 = -1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n magnitude = np.sqrt(np.sum(J**2,axis=1))\n return J.T/magnitude\n def posZJ(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1);yb=np.array(-xi2);zb=np.ones(xi1.shape);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n dxdxi2 = -1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\n dydxi2 = -1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\n dzdxi2 = -1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n return np.sqrt(np.sum(J**2,axis=1))\n mesh.eList[4].vals = posZvals\n mesh.eList[4].normals = posZnormals\n mesh.eList[4].J = posZJ\n \n # z=-1 side\n def negZvals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1);yb=np.array(xi2);zb=-np.ones(xi1.shape);\n xx=xb**2;yy=yb**2;zz=zb**2;\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\n return np.vstack([x,y,z])\n def negZnormals(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1);yb=np.array(xi2);zb=-np.ones(xi1.shape);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\n dydxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\n dzdxi2 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n magnitude = np.sqrt(np.sum(J**2,axis=1))\n return J.T/magnitude\n def negZJ(xi1,xi2):\n xi1=np.asarray(xi1,np.float).reshape(-1,)\n xi2=np.asarray(xi2,np.float).reshape(-1,)\n xb=np.array(xi1);yb=np.array(xi2);zb=-np.ones(xi1.shape);\n xx=xb**2;yy=yb**2;zz=zb**2;\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\n dydxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\n dzdxi2 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\n J = np.cross(J[:,0,:],J[:,1,:])\n return np.sqrt(np.sum(J**2,axis=1))\n mesh.eList[5].vals = negZvals\n mesh.eList[5].normals = negZnormals\n mesh.eList[5].J = negZJ\n \n for e in mesh.eList:\n e.ExactElement = True\n \n return mesh","def get_correct_coords(start_x=0,viewing_distance=12.0,field_height=10,field_width=10,pixel_width=0.282,pixel_height=0.282,**config):\n \n x = (start_x + np.arange(np.ceil(-field_width/2.0),np.ceil(field_width/2.0),1))*pixel_width\n y = np.arange(np.ceil(-field_height/2.0),np.ceil(field_height/2.0),1)*pixel_height\n x,y = np.meshgrid(x,y)\n coords = np.vstack((x.ravel(),y.ravel())).T\n return coords","def sample_camera_positions(device,\n bs=1,\n r=1,\n horizontal_stddev=1,\n vertical_stddev=1,\n horizontal_mean=math.pi * 0.5,\n vertical_mean=math.pi * 0.5,\n mode='normal'):\n\n if mode == 'uniform':\n theta = (torch.rand((bs, 1), device=device) - 0.5) \\\n * 2 * horizontal_stddev \\\n + horizontal_mean\n phi = (torch.rand((bs, 1), device=device) - 0.5) \\\n * 2 * vertical_stddev \\\n + vertical_mean\n\n elif mode == 'normal' or mode == 'gaussian':\n theta = torch.randn((bs, 1), device=device) \\\n * horizontal_stddev \\\n + horizontal_mean\n phi = torch.randn((bs, 1), device=device) \\\n * vertical_stddev \\\n + vertical_mean\n\n elif mode == 'hybrid':\n if random.random() < 0.5:\n theta = (torch.rand((bs, 1), device=device) - 0.5) \\\n * 2 * horizontal_stddev * 2 \\\n + horizontal_mean\n phi = (torch.rand((bs, 1), device=device) - 0.5) \\\n * 2 * vertical_stddev * 2 \\\n + vertical_mean\n else:\n theta = torch.randn((bs, 1), device=device) * horizontal_stddev + horizontal_mean\n phi = torch.randn((bs, 1), device=device) * vertical_stddev + vertical_mean\n\n elif mode == 'truncated_gaussian':\n theta = truncated_normal_(torch.zeros((bs, 1), device=device)) \\\n * horizontal_stddev \\\n + horizontal_mean\n phi = truncated_normal_(torch.zeros((bs, 1), device=device)) \\\n * vertical_stddev \\\n + vertical_mean\n\n elif mode == 'spherical_uniform':\n theta = (torch.rand((bs, 1), device=device) - .5) \\\n * 2 * horizontal_stddev \\\n + horizontal_mean\n v_stddev, v_mean = vertical_stddev / math.pi, vertical_mean / math.pi\n v = ((torch.rand((bs, 1), device=device) - .5) * 2 * v_stddev + v_mean)\n v = torch.clamp(v, 1e-5, 1 - 1e-5)\n phi = torch.arccos(1 - 2 * v)\n\n elif mode == 'mean':\n # Just use the mean.\n theta = torch.ones((bs, 1), device=device, dtype=torch.float) * horizontal_mean\n phi = torch.ones((bs, 1), device=device, dtype=torch.float) * vertical_mean\n else:\n assert 0\n\n phi = torch.clamp(phi, 1e-5, math.pi - 1e-5)\n\n output_points = torch.zeros((bs, 3), device=device) # (bs, 3)\n output_points[:, 0:1] = r * torch.sin(phi) * torch.cos(theta) # x\n output_points[:, 2:3] = r * torch.sin(phi) * torch.sin(theta) # z\n output_points[:, 1:2] = r * torch.cos(phi) # y\n\n return output_points, phi, theta","def magn(names, values, data, model_key, plot_key=False):\n # Making sure number of parameters matches number of names given:\n assert len(names) == len(values), \"len(names) != len(values) in datasim.magn\"\n\n zpicks = data['zpicks']\n # Corrected absolute magnitude M of SN.\n M = values[0]\n\n# dlpc, da, integrated_zpicks, integrated_dlpc, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\n\n dlpc, da, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\n\n # Calculating apparent magnitudes of supernovae at the simulated\n # luminosity distances using the distance modulus formula.\n mag = 5 * np.log10(dlpc/10) + M\n# integrated_mag = 5 * np.log10(integrated_dlpc/10) + M\n# print('redshift =',zpicks[-1],'da =', da[-1])\n\n# # plotting interpoated data vs input and full\n# import matplotlib.pyplot as plt\n# import matplotlib as mpl\n# #mpl.style.use('default') # has to be switched on to set figure size\n# mpl.style.use('fivethirtyeight')\n# plt.rcParams['axes.facecolor'] = 'white'\n# plt.rcParams['figure.facecolor'] = 'white'\n# plt.rcParams['grid.color'] = 'white'\n#\n# print('integrated_zpicks',integrated_zpicks[0])\n# print('zpicks', zpicks[0])\n#\n# plt.figure()\n# plt.scatter(integrated_zpicks, integrated_mag, s=70, label='integrated', c=\"C{}\".format(0))\n# plt.plot(zpicks, mag, label='interpolated', linestyle='-', c=\"C{}\".format(1))\n# plt.legend()\n\n if plot_key:\n # Plotting evolution of parameters in the model.\n import plots\n plots.modelcheck(mag, zpicks, plot_var, model_key)\n\n return mag, da","def calculate_useful_stuff(self):\n\n self.pos = self.pair[1].position - self.pair[0].position\n self.vel = self.pair[1].velocity - self.pair[0].velocity\n\n self.r = self.pos.length()\n self.v = self.vel.length()\n self.inv_r = 1.0 / self.r\n\n self.rvec = self.pos * self.inv_r\n self.rdot = (self.rvec * self.vel).sum() * self.rvec\n self.rdot_mag = self.rdot.length()\n\n self.vth = self.vel - self.rdot\n self.vth_mag = self.vth.length()\n self.vth_vec = self.vth / self.vth_mag","def trap_depth_old(V,X,Y,Z,Im,Jm,Km,debug=False): \n from project_parameters import debug\n #from all_functions import sum_of_e_field\n def a(a,N):\n \"\"\"Shortcut function to convert array x into a row vector.\"\"\" \n a=np.ravel(a, order='F') # Same order\n return a\n def index_sort(y,x):\n \"\"\"Takes in two lists of the same length and returns y sorted by the indexing of x sorted.\"\"\"\n xs=np.sort(x)\n ix=np.argsort(x)\n ys=np.ones(len(y)) #Sorted by the sorting defined by f being sorted. \n for i in range(len(y)):\n j=ix[i]\n ys[i]=y[j]\n return ys\n if len(V.shape)!=3:\n return('Problem with find_saddle.py dimensionalities.\\n')\n N1,N2,N3=V.shape\n N=N1*N2*N3\n f=V\n [Ex,Ey,Ez]=np.gradient(f,abs(X[1]-X[0]),abs(Y[1]-Y[0]),abs(Z[1]-Z[0]))\n E=np.sqrt(Ex**2+Ey**2+Ez**2)\n fs,Es=a(f,N),a(E,N) # Convert 3D to 1D array\n fs,Es=np.real(fs),np.real(Es)\n # identify the escape position and height by checking each point\n minElectricField=max(fs) # initialize as maximum E field magnitude\n distance=0\n escapeHeight=1\n escapePosition=[0,0,0]\n for i in range(N1):\n for j in range(N2):\n for k in range(N3):\n if [i,j,k]==[Im,Jm,Km]:\n Vm=V[i,j,k]\n elif E[i,j,k]<minElectricField:\n minElectricField=E[i,j,k]\n escapeHeight=V[i,j,k]\n escapePosition=[i,j,k]\n distance=abs(Im+Jm+Km-i-j-k) \n if debug.trap_depth: # plot sortings of potential and electric field to view escape position\n plt.plot(np.sort(fs)) \n plt.title('sorted potential field')\n plt.show()\n plt.plot(np.sort(Es)) \n plt.title('sorted electric field')\n plt.show()\n q1=index_sort(fs,Es) \n plt.title('potential field sorted by sorted indexing of electric field')\n plt.plot(q1)\n plt.show()\n q2=index_sort(Es,fs) \n plt.title('electric field sorted by sorted indexing of potential field')\n plt.plot(q2)\n plt.show() \n check=1 \n if debug.trap_depth: \n print minElectricField,escapeHeight,escapePosition,distance \n if distance<check:\n print('trap_depth.py: Escape point too close to trap minimum. Improve grid resolution or extend grid.')\n if escapeHeight>0.2:\n print('trap_depth.py: Escape point parameter too high. Improve grid resolution or extend grid.')\n D=escapeHeight-Vm\n [Ie,Je,Ke]=escapePosition\n [Xe,Ye,Ze]=[X[Ie],Y[Je],Z[Ke]] \n return [D,Xe,Ye,Ze]","def test_jam_axi_rms():\n np.random.seed(123)\n xbin, ybin = np.random.uniform(low=[-55, -40], high=[55, 40], size=[1000, 2]).T\n\n inc = 60. # Assumed galaxy inclination\n r = np.sqrt(xbin**2 + (ybin/np.cos(np.radians(inc)))**2) # Radius in the plane of the disk\n a = 40 # Scale length in arcsec\n vr = 2000*np.sqrt(r)/(r+a) # Assumed velocity profile\n vel = vr * np.sin(np.radians(inc))*xbin/r # Projected velocity field\n sig = 8700/(r+a) # Assumed velocity dispersion profile\n rms = np.sqrt(vel**2 + sig**2) # Vrms field in km/s\n\n surf = np.array([39483., 37158., 30646., 17759., 5955.1, 1203.5, 174.36, 21.105, 2.3599, 0.25493])\n sigma = np.array([0.153, 0.515, 1.58, 4.22, 10, 22.4, 48.8, 105, 227, 525])\n qObs = np.full_like(sigma, 0.57)\n\n distance = 16.5 # Assume Virgo distance in Mpc (Mei et al. 2007)\n mbh = 1e8 # Black hole mass in solar masses\n beta = np.full_like(surf, 0.3)\n\n surf_lum = surf # Assume self-consistency\n sigma_lum = sigma\n qobs_lum = qObs\n surf_pot = surf\n sigma_pot = sigma\n qobs_pot = qObs\n\n sigmapsf = 0.6\n pixsize = 0.8\n goodbins = r > 10 # Arbitrarily exclude the center to illustrate how to use goodbins\n\n # The model is similar but not identical to the adopted kinematics!\n rmsModel, ml, chi2, flux = jam_axi_rms(\n surf_lum, sigma_lum, qobs_lum, surf_pot, sigma_pot, qobs_pot,\n inc, mbh, distance, xbin, ybin, plot=True, rms=rms, sigmapsf=sigmapsf,\n beta=beta, pixsize=pixsize, tensor='zz', goodbins=goodbins)\n plt.pause(0.01)","def calc_magnitude(box,octant):\n # Read the Mi(z=2) magnitudes for the box.\n miz2 = FH.read_file(box)['Miz2'][:]\n # Read the index for each QSO in the octant, and get the Mi(z=2).\n data = FH.read_file(octant)\n zz = data['Z']\n dmod = data['DMOD']\n miz2 = miz2[data['INDX']]\n # Now convert to apparent i-band magnitude using the k-correction.\n # If a tabulated k-correction is available, use that, otherwise\n # default to a power-law continuum approximation.\n # See discussion in Ross++13, Appendix B and Section 4.\n kfile=os.getenv('MOCKINGDESI_BASE')+\"/data/qso-iband-k-correction.txt\"\n if os.path.exists(kfile):\n print(\"Using K-correction from \"+kfile)\n kcorr = np.loadtxt(kfile)\n kcorr = np.interp(zz,kcorr[:,1],kcorr[:,2])\n else:\n print(\"Using power-law K-correction\")\n alpha = -0.5\n kcorr = -2.5*(1+alpha)*np.log10( (1+zz)/(1+2.0) )\n gmi = np.poly1d([0.1502,-0.9886,2.147,-1.758,0.6397])\t# See notes.\n rmi = np.poly1d([-0.1482,1.636,-6.716,12.55,-10.39,3.017])\n magi = miz2 + dmod + kcorr\t# e.g. Ross++13, Eq. 5\n magg = magi + gmi(zz.clip(0.5,3.5))\n magr = magi + rmi(zz.clip(0.5,3.5))\n # and write the results\n data = {}\n data['GMAG'] = magg.astype('f4')\n data['RMAG'] = magr.astype('f4')\n FH.write_file(octant,data)\n #","def GetDetectorData(detectorName):\n\n # Allocate direction vectors and position of IFO given detectorName\n detPosVector = np.zeros(3)\n nx = np.zeros(3)\n ny = np.zeros(3)\n\n ################# aLIGO HANFORD #############\n if detectorName == 'H1':\n\tnx[0] = -0.22389266154\n\tnx[1] = 0.79983062746\n\tnx[2] = 0.55690487831\n\n\tny[0] = -0.91397818574\n\tny[1] = 0.02609403989\n\tny[2] = -0.40492342125\n\n\tdetPosVector[0] = -2.16141492636e6\n\tdetPosVector[1] = -3.83469517889e6\n\tdetPosVector[2] = 4.60035022664e6\n ################# aLIGO LIVINGSTON ##########\n elif detectorName == 'L1':\n\tnx[0] = -0.95457412153\n\tnx[1] = -0.14158077340\n\tnx[2] = -0.26218911324\n\n\tny[0] = 0.29774156894\n\tny[1] = -0.48791033647 \n\tny[2] = -0.82054461286\n\n\tdetPosVector[0] = -7.42760447238e4\n\tdetPosVector[1] = -5.49628371971e6\n\tdetPosVector[2] = 3.22425701744e6\n ################# AdvVIRGO ##################\n elif detectorName == 'V1':\n\tnx[0] = -0.70045821479\n nx[1] = 0.20848948619\n nx[2] = 0.68256166277\n\n ny[0] = -0.05379255368 \n ny[1] = -0.96908180549\n ny[2] = 0.24080451708\n\n detPosVector[0] = 4.54637409900e6\n detPosVector[1] = 8.42989697626e5\n detPosVector[2] = 4.37857696241e6\n ################# INDIGO ####################\n elif detectorName == 'I1':\n\t# Not cached LIGO detector - construct x, nx and ny from other\n\t# quantities\n\tvxLat = (14. + 14./60.)*(np.pi/180.) # Vertex latitude\n\tvxLon = (76. + 26./60.)*(np.pi/180.) # Vertex longitude\n\tvxElev = 0. # Vertex elevation\n\txAlt = 0. # Altitude of x-arm\n\tyAlt = 0. # Altitude of y-arm\n\txAz = np.pi/2. # Azimuth of x-arm\n\tyAz = 0. # Azimuth of y-arm\n\n\tcosLat = np.cos(vxLat)\n sinLat = np.sin(vxLat)\n cosLon = np.cos(vxLon)\n sinLon = np.sin(vxLon)\n\n ellDenom = np.sqrt(AWGS84*AWGS84*cosLat*cosLat + \\\n BWGS84*BWGS84*sinLat*sinLat)\n locRho = cosLat*(AWGS84*AWGS84/ellDenom + vxElev)\n \n # Position\n detPosVector[0] = locRho*cosLon\n detPosVector[1] = locRho*sinLon\n detPosVector[2] = sinLat*(BWGS84*BWGS84/ellDenom + vxElev)\n\n # x-Arm vector\n cosxAlt = np.cos(xAlt)\n sinxAlt = np.sin(xAlt)\n cosxAz = np.cos(xAz)\n sinxAz = np.sin(xAz)\n uxNorth = cosxAlt*cosxAz\n uxEast = cosxAlt*sinxAz\n uxRho = -sinLat*uxNorth + cosLat*sinxAlt\n\n nx[0] = cosLon*uxRho - sinLon*uxEast\n nx[1] = sinLon*uxRho + cosLon*uxEast\n nx[2] = cosLat*uxNorth + sinLat*sinxAlt\n\n # y-Arm vector\n cosyAlt = np.cos(yAlt)\n sinyAlt = np.sin(yAlt)\n cosyAz = np.cos(yAz)\n sinyAz = np.sin(yAz)\n uyNorth = cosyAlt*cosyAz\n uyEast = cosyAlt*sinyAz\n uyRho = -sinLat*uyNorth + cosLat*sinyAlt\n\n ny[0] = cosLon*uyRho - sinLon*uyEast\n ny[1] = sinLon*uyRho + cosLon*uyEast\n ny[2] = cosLat*uyNorth + sinLat*sinyAlt\n\n ################# KAGRA #####################\n elif detectorName == 'K1':\n\t# Not cached LIGO detector - construct x, nx and ny from other\n # quantities\n vxLat = (36.25)*(np.pi/180.) # Vertex latitude\n vxLon = (137.18)*(np.pi/180.) # Vertex longitude\n vxElev = 0. # Vertex elevation\n xAlt = 0. # Altitude of x-arm\n yAlt = 0. # Altitude of y-arm\n xMid = 1500. # Midpoint of x-arm\n yMid = 1500. # Midpoint of y-arm\n xAz = 19.*(np.pi/180.) + np.pi/2. # Azimuth of x-arm\n yAz = 19.*(np.pi/180.) # Azimuth of y-arm\n\n cosLat = np.cos(vxLat)\n\tsinLat = np.sin(vxLat)\n\tcosLon = np.cos(vxLon)\n\tsinLon = np.sin(vxLon)\n\n\tellDenom = np.sqrt(AWGS84*AWGS84*cosLat*cosLat + \\\n\t\t BWGS84*BWGS84*sinLat*sinLat)\n\tlocRho = cosLat*(AWGS84*AWGS84/ellDenom + vxElev)\n\n\t# Position\n\tdetPosVector[0] = locRho*cosLon\n\tdetPosVector[1] = locRho*sinLon\n\tdetPosVector[2] = sinLat*(BWGS84*BWGS84/ellDenom + vxElev)\n\n\t# x-Arm vector\n\tcosxAlt = np.cos(xAlt)\n\tsinxAlt = np.sin(xAlt)\n\tcosxAz = np.cos(xAz)\n\tsinxAz = np.sin(xAz) \n\tuxNorth = cosxAlt*cosxAz\n\tuxEast = cosxAlt*sinxAz\n\tuxRho = -sinLat*uxNorth + cosLat*sinxAlt\n\n\tnx[0] = cosLon*uxRho - sinLon*uxEast\n\tnx[1] = sinLon*uxRho + cosLon*uxEast\n\tnx[2] = cosLat*uxNorth + sinLat*sinxAlt\n\n\t# y-Arm vector\n\tcosyAlt = np.cos(yAlt)\n sinyAlt = np.sin(yAlt)\n cosyAz = np.cos(yAz)\n sinyAz = np.sin(yAz)\n\tuyNorth = cosyAlt*cosyAz\n uyEast = cosyAlt*sinyAz\n uyRho = -sinLat*uyNorth + cosLat*sinyAlt\n\n ny[0] = cosLon*uyRho - sinLon*uyEast\n ny[1] = sinLon*uyRho + cosLon*uyEast\n ny[2] = cosLat*uyNorth + sinLat*sinyAlt\n\n # Compute detRespTensor as \n # detRespTensor = 0.5(nx \\outerprod nx - ny \\outerprod ny)\n detRespTensor = np.zeros((3,3),float)\n for i in range(0,3):\n\tfor j in range(0,3):\n\t detRespTensor[i,j] = (nx[i]*nx[j] - ny[i]*ny[j])*0.5\n\n return detRespTensor,detPosVector","def calc_body_pos(component, time):\r\n # Convert to radians\r\n M = radians(eval(component.orbit['M'])(time))\r\n w = radians(eval(component.orbit['w'])(time))\r\n i = radians(eval(component.orbit['i'])(time))\r\n N = radians(eval(component.orbit['N'])(time))\r\n a = component.orbit['a']\r\n e = eval(component.orbit['e'])(time)\r\n # Compute eccentric anomaly\r\n E = M + e * sin(M) * (1.0 + e * cos(M))\r\n if degrees(E) > 0.05:\r\n E = compute_e(E, M, e)\r\n # http://stjarnhimlen.se/comp/tutorial.html\r\n # Compute distance and true anomaly\r\n xv = a * (cos(E) - e)\r\n yv = a * (sqrt(1.0 - e * e) * sin(E))\r\n v = atan2(yv, xv)\r\n r = sqrt(xv * xv + yv * yv)\r\n xh = r * (cos(N) * cos(v + w) - sin(N) * sin(v + w) * cos(i))\r\n yh = r * (sin(N) * cos(v + w) + cos(N) * sin(v + w) * cos(i))\r\n if is2d:\r\n zh = 0\r\n else:\r\n zh = r * (sin(v + w) * sin(i))\r\n '''The above assumes looking \"down\" on the solar system where x and y are\r\n the circle and z = 0 is on the heliocentric ecliptic. Panda3d uses the above.\r\n Opengl is y up and z depth so we switch the y and z coordinates below..'''\r\n #TODO: z+ is out of the screen so check if we need to flip the sign of zh\r\n '''xh = r * (cos(N) * cos(v + w) - sin(N) * sin(v + w) * cos(i))\r\n zh = r * (sin(N) * cos(v + w) + cos(N) * sin(v + w) * cos(i))\r\n if is2d:\r\n yh = 0\r\n else:\r\n yh = r * (sin(v + w) * sin(i))'''\r\n position = LPoint3d(xh, yh, zh)\r\n # If we are not a moon then our orbits are done in au.\r\n # Moons are done in km\r\n # Our units in panda are m, so we convert to m\r\n if component.kind != cel_comp.TYPES['moon']:\r\n position *= 149598000\r\n position *= 1000\r\n return position","def get_vector_field(self, key):\n f1 = self.get_field(key + '1')\n f2 = self.get_field(key + '2')\n f3 = self.get_field(key + '3')\n x, y, z = self.get_cell_center_coordinates()\n if self.geometry == 'cartesian':\n fx = f1\n fy = f2\n fz = f3\n elif self.geometry == 'spherical':\n \"\"\"\n http://en.wikipedia.org/wiki/\n List_of_common_coordinate_transformations#To_Spherical_coordinates\n \"\"\"\n r2 = x**2 + y**2 + z**2\n rh = [x/r2**0.5, y/r2**0.5, z/r2**0.5]\n th = [x*z/r2*(x**2 + y**2)**-0.5,\n y*z/r2*(x**2 + y**2)**-0.5,\n -1./r2*(x**2 + y**2)**+0.5] \n ph = [-y/(x**2 + y**2)+0*r2, x/(x**2 + y**2)+0*r2, 0*r2]\n fx = f1*rh[0] + f2*th[0] + f3*ph[0]\n fy = f1*rh[1] + f2*th[1] + f3*ph[1]\n fz = f1*rh[2] + f2*th[2] + f3*ph[2]\n return fx, fy, fz","def main():\n cam = Realsense()\n # cam.access_intr_and_extr()\n profile = cam.pipeline.start(cam.config)\n depth_sensor = profile.get_device().first_depth_sensor()\n depth_scale = depth_sensor.get_depth_scale()\n align_to = rs.stream.color\n align = rs.align(align_to)\n\n objp = np.zeros((3*4,3), np.float32)\n objp[:,:2] = np.mgrid[0:4,0:3].T.reshape(-1,2)\n axis = np.float32([[1,0,0], [0,1,0], [0,0,-1]]).reshape(-1,3)\n # print(objp)\n\n try:\n while (True):\n # detect ArUco markers in RGB images\n frames = cam.pipeline.wait_for_frames()\n aligned_frames = align.process(frames)\n color_frame = aligned_frames.get_color_frame()\n color_image = np.asanyarray(color_frame.get_data()) \n frame = color_image\n font = cv2.FONT_HERSHEY_SIMPLEX\n corners, ids, rvecs, tvecs = cam.detect_markers_realsense(frame)\n \n if np.all(ids != None): # if markers are detected\n for i in range(0, ids.size):\n aruco.drawAxis(frame, cam.newcameramtx, cam.dist, rvecs[i],\n tvecs[i], 0.1) # Draw axis\n aruco.drawDetectedMarkers(frame, corners) # draw square around markers\n\n ###### DRAW ID #####\n strg = ''\n for i in range(0, ids.size):\n strg += str(ids[i][0])+', '\n\n cv2.putText(frame, \"Id: \" + strg, (0,25), font, 1, (0,255,0), 2,\n cv2.LINE_AA)\n\n\t ###### Output marker positions in camera frame ######\n \t # output tvec\n y0 = 60\n dy = 40\n for i in range(0, ids.size):\n y = y0 + i*dy\n cv2.putText(frame, str(tvecs[i][0]), (0, y), font, 1, (0,255,0),\n 2, cv2.LINE_AA)\n\n else:\n ##### DRAW \"NO IDS\" #####\n cv2.putText(frame, \"No Ids\", (0,64), font, 1, (0,255,0), 2,\n cv2.LINE_AA)\n\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n ret, corners = cv2.findChessboardCorners(gray, (4,3), None)\n if ret == True:\n corners2 = cv2.cornerSubPix(gray, corners,(11,11), (-1,-1),\n cam.criteria)\n corners2 = corners2[::-1]\n # print(corners2)\n # print(objp)\n frame = cv2.drawChessboardCorners(frame, (4,3), corners2, ret)\n # Find the rotation and translation vectors.\n _, rvecs, tvecs = cv2.solvePnP(objp, corners2, cam.newcameramtx,\n cam.dist)\n rot, _ = cv2.Rodrigues(rvecs)\n # print(rot)\n # project 3D points to image plane\n imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs,\n cam.newcameramtx, cam.dist)\n frame = draw(frame, corners2, imgpts)\n\n # Display the resulting frame\n cv2.imshow('frame',frame)\n cv2.waitKey(5)\n\n # When everything done, release the capture\n cv2.destroyAllWindows()\n\n finally:\n cam.pipeline.stop()","def getCarLocation():\n cams = CAMS\n img1, img2 = cams[0].getImage(), cams[1].getImage()\n potint1op, point2op = GetBalloonOld.getCar(img1), GetBalloonOld.getCar(\n img2)\n for j in range(len(point1op)):\n point1op[j] = np.array(np.array([point1op[j][0], point1op[j][1]]))\n for j in range(len(point2op)):\n point2op[j] = np.array(np.array([point2op[j][0], point2op[j][1]]))\n if len(point1op) == 0 or len(point2op) == 0:\n return None\n points = [[point1op[0]], [point2op[0]]]\n car = getTargetsPlaces(copy.deepcopy(points))[0]\n diff = abs(car[2] - CAR_Z)\n for op1 in point1op:\n for op2 in point2op:\n testPoint = [[op1], [op2]]\n testCar = getTargetsPlaces(copy.deepcopy(testPoint))[0]\n testDiff = abs(testCar[2] - CAR_Z)\n if testDiff < diff:\n diff = testDiff\n car = testCar\n return car","def force ( box, strain, r ):\n\n import numpy as np\n from itertools import product\n import math\n \n # It is assumed that positions are in units where box = 1\n # Forces are calculated in units where sigma = 1 and epsilon = 1\n # Lees-Edwards boundaries, in sliding brick arrangement\n # Flow/gradient/vorticity directions are x/y/z == 0/1/2\n # Uses neighbour lists\n\n n = r.shape[0]\n\n # Set up vectors to half the cells in neighbourhood of 3x3x3 cells in cubic lattice\n # The cells are chosen so that if (d0,d1,d2) appears, then (-d0,-d1,-d2) does not.\n # The last three cells are extra ones, to cope with the sheared system\n d = np.array ( [ [ 0, 0, 0], [ 1, 0, 0], [ 1, 0, 1], [-1, 0, 1], [ 0, 0, 1], # 5 cells with d1=0\n [ 1, 1, -1], [ 1, 1, 0], [ 1, 1, 1], # 3 cells with d0= 1, d1=1\n [ 0, 1, -1], [ 0, 1, 0], [ 0, 1, 1], # 3 cells with d0= 0, d1=1\n [-1, 1, -1], [-1, 1, 0], [-1, 1, 1], # 3 cells with d0=-1, d1=1\n [-2, 1, -1], [-2, 1, 0], [-2, 1, 1] ] ) # 3 cells with d0=-2, d1=1\n\n r[:,0] = r[:,0] - np.rint(r[:,1])*strain # Extra correction in box=1 units\n r = r - np.rint(r) # Ensure all atoms in periodic box\n \n sr2_ovr = 1.77 # Overlap threshold (pot > 100)\n r_cut_box = r_cut / box\n r_cut_box_sq = r_cut_box ** 2\n box_sq = box ** 2\n\n # Initialize\n f = np.zeros_like(r)\n total = PotentialType ( pot=0.0, vir=0.0, pyx=0.0, lap=0.0, ovr=False )\n\n # Calculate cell index triplets\n sc = math.floor(box/r_cut) # Number of cells along box edge\n assert sc >= 3, 'System is too small for cells' # Guard against box being too small\n c = np.floor((r+0.5)*sc).astype(np.int_) # N*3 array of cell indices for all atoms\n assert np.all(c>=0) and np.all(c<sc), 'Index error' # Simplistic \"guard\" against roundoff\n\n shift = math.floor(strain*sc) # Strain measured in cell lengths\n\n if fast:\n \n # Build list of arrays, each array holding positions of atoms in a cell\n # At the same time, define a matching set of force arrays in each cell\n # i and j number the atoms in each cell; we do not refer explicitly to indices in r\n rc, fc = [], [] # Initially empty lists of positions and forces\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n rc.append(r[mask,:]) # Copy atom coordinates into array, add to list\n fc.append(np.zeros_like(rc[-1])) # Zero corresponding forces, add to list\n\n for ci1, rci in enumerate(rc): # Loop over i-cells, getting all atoms in each i-cell as an array\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\n if rci.size==0: # Handle empty cell\n continue\n\n # Set up correct neighbour cell indices\n if ci[1]==sc-1: # i-cell is in the top layer\n dd = d.copy() # Standard list copied, including extra 3 cells\n dd[5:,0] = d[5:,0] - shift # All those looking up need adjustment in the x direction\n else: # i-cell is not in top layer\n dd = d[:-3,:].copy() # Last three extra cells are not needed; shift is not needed\n \n for dj in dd: # Loop over neighbouring j-cells\n cj = ci + dj # Compute neighbour j-cell triple-indices\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert j-cell to single-index\n rcj = rc[cj1] # Get atoms in j-cell as an array\n if rcj.size==0: # Handle empty cell\n continue\n\n rij = rci[:,np.newaxis,:]-rcj[np.newaxis,:,:] # Separation vectors for all i and j\n rij[:,:,0] = rij[:,:,0] - np.rint(rij[:,:,1])*strain # Extra correction in box=1 units\n rij = rij - np.rint(rij) # PBCs in box=1 units\n rij_sq = np.sum(rij**2,axis=2) # Squared separations\n in_range = rij_sq < r_cut_box_sq # Set flags for within cutoff\n\n if ci1==cj1:\n np.fill_diagonal(in_range,False) # Eliminate i==j when i-cell==j-cell\n np.fill_diagonal(rij_sq,1.0) # Avoid divide-by-zero below\n\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\n rij = rij * box # Now in sigma=1 units\n sr2 = np.where ( in_range, 1.0/rij_sq, 0.0 ) # (sigma/rij)**2, only if in range\n ovr = sr2 > sr2_ovr # Overlap if too close\n sr6 = sr2 ** 3\n sr12 = sr6 ** 2\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\n vir = pot + sr12 # LJ virial\n pot = np.where ( in_range, pot+0.25, 0.0 ) # WCA LJ pair potential (cut-and-shifted)\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\n fij = vir * sr2 # LJ scalar part of forces\n fij = rij * fij[:,:,np.newaxis] # LJ pair forces\n pyx = rij[:,:,1]*fij[:,:,0] # Off-diagonal element of pressure tensor\n\n if ci1==cj1: # Correct for double-counting ij and ji when i-cell==j-cell\n fij = fij / 2\n total = total + PotentialType ( pot=np.sum(pot)/2, vir=np.sum(vir)/2, \n pyx=np.sum(pyx)/2, lap=np.sum(lap)/2, ovr=np.any(ovr) )\n else:\n total = total + PotentialType ( pot=np.sum(pot), vir=np.sum(vir), \n pyx=np.sum(pyx), lap=np.sum(lap), ovr=np.any(ovr) )\n\n fc[ci1][:,:] = fc[ci1][:,:] + np.sum(fij,axis=1) # Aggregate force on atoms in i-cell\n fc[cj1][:,:] = fc[cj1][:,:] - np.sum(fij,axis=0) # Aggregate force on atoms in j-cell\n\n # Copy forces from list of cell arrays to main force array\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n ci1 = np.ravel_multi_index(ci,(sc,sc,sc),mode='wrap') # Single-index\n f[mask,:] = fc[ci1] # Copy atom forces from correct cell\n\n else:\n \n # Build list of arrays, each array holding indices of atoms in a cell\n # ki and kj are atom indices in the r array; i and j number the atoms in each cell\n k_array = np.arange(n) # Atom indices 0..N-1\n kc = [] # Initially empty list of indices\n for ci in product(range(sc),repeat=3): # Triple loop over cells\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\n kc.append(k_array[mask]) # Copy atom indices into array, add to list\n\n for ci1, kci in enumerate(kc): # Loop over i-cells, getting atom indices as an array\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\n\n # Set up correct neighbour cell indices\n if ci[1]==sc-1: # i-cell is in the top layer\n dd = d # Standard list copied, including extra 3 cells\n dd[5:,0] = dd[5:,0] - shift # All those looking up need adjustment in the x direction\n else:\n dd = d[:-3,:] # Last three extra cells are not needed; shift is not needed\n\n for dj in dd: # Loop over neighbouring j-cells\n cj = ci + dj # Compute neighbour j-cell triple-indices\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert to single-index\n kcj = kc[cj1] # Get indices of atoms in j-cell as an array\n\n for i, ki in enumerate(kci): # Loop over individual atoms in i-cell\n j0 = i+1 if cj1==ci1 else 0 # Only look upwards if i-cell==j-cell\n if j0 >= kcj.size: # Handles (redundantly) empty j-cell and the case \n continue # where j-cell==i-cell and i is last atom\n\n for kj in kcj[j0:]: # Loop over individual atoms in j-cell\n rij = r[ki,:]-r[kj,:] # Separation vector\n rij[0] = rij[0] - np.rint(rij[1])*strain # Extra correction in box=1 units\n rij = rij - np.rint(rij) # Periodic boundary conditions in box=1 units\n rij_sq = np.sum(rij**2) # Squared separation\n\n if rij_sq < r_cut_box_sq: # Check within cutoff\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\n rij = rij * box # Now in sigma=1 units\n sr2 = 1.0 / rij_sq # (sigma/rij)**2\n ovr = sr2 > sr2_ovr # Overlap if too close\n sr6 = sr2 ** 3\n sr12 = sr6 ** 2\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\n vir = pot + sr12 # LJ virial\n pot = pot + 0.25 # WCA LJ potential (cut-and-shifted)\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\n fij = rij * vir * sr2 # LJ forces\n pyx = rij[1]*fij[0] # Off-diagonal element of pressure tensor\n total = total + PotentialType ( pot=pot, vir=vir, pyx=pyx, lap=lap, ovr=ovr )\n f[ki,:] = f[ki,:] + fij\n f[kj,:] = f[kj,:] - fij\n\n # Multiply results by numerical factors\n f = f * 24.0 # 24*epsilon\n total.pot = total.pot * 4.0 # 4*epsilon\n total.vir = total.vir * 24.0 / 3.0 # 24*epsilon and divide virial by 3\n total.pyx = total.pyx * 24.0 # 24*epsilon\n total.lap = total.lap * 24.0 * 2.0 # 24*epsilon and factor 2 for ij and ji\n \n return total, f","def add_cam(self, xpos, ypos, follower_len, bumps=[], horizontal=False, reverse_direction=False, axis_offset=0, axis=True, bump_height=3, slow_rise=False):\n attachment_body = self.groundBody\n offset = 0\n if not horizontal:\n offset = -0.25\n if reverse_direction:\n offset = 0.5\n for b in range(0,len(bumps)):\n bumps[b] = (bumps[b][0] + offset, bumps[b][1])\n radius = 30\n bump_height = radius+bump_height\n disc_fixture = fixtureDef(shape=circleShape(radius=radius, pos=(0,0)),density=1.0,filter=filters[0])\n bump_fixtures = []\n\n if slow_rise:\n ang=bumps[0][0]\n bump_points = [( radius*math.cos(-ang*math.pi*2), radius*math.sin(-ang*math.pi*2)) ]\n height = radius\n for point in range(0,14):\n ang += 0.015\n height += 0.3\n bump_points.append( ( height*math.cos(-ang*math.pi*2), height*math.sin(-ang*math.pi*2)) )\n bump_points.append(( radius*math.cos(-ang*math.pi*2), radius*math.sin(-ang*math.pi*2)))\n bump_fixtures.append(fixtureDef(shape=polygonShape(vertices=bump_points),density=0.0,filter=filters[0]))\n else:\n for (start, length) in bumps:\n ang = start\n bump_points = [( radius*math.cos(-ang*math.pi*2), radius*math.sin(-ang*math.pi*2)) ]\n points = 1\n # Max points in a polygon is 15 at the moment.\n while ang < (start+length) and points < 15:\n ang += 0.02\n bump_points.append( ( bump_height*math.cos(-ang*math.pi*2), bump_height*math.sin(-ang*math.pi*2)) )\n points += 1\n if points == 15:\n print(\"WARNING: Max points reached in cam bump; %2.2d%% of cam complete\"%(100*(ang-start)/length))\n\n bump_points.append(( radius*math.cos(-(ang+0.01)*math.pi*2), radius*math.sin(-(ang+0.01)*math.pi*2)))\n f = fixtureDef(shape=polygonShape(vertices=bump_points),density=0.0,filter=filters[0], userData=(0,0,255))\n bump_fixtures.append(f)\n cam_body = self.add_multifixture(bump_fixtures + [disc_fixture], xpos, ypos, (0,255,0))\n cam_driver = self.revolving_joint(attachment_body, cam_body, (xpos,ypos), motor=1, force=50)\n cam_driver.motorSpeed = 0\n follower_filter = filters[1]\n if axis:\n if horizontal:\n axle_y = ypos+radius\n if reverse_direction:\n axle_x = xpos-radius-axis_offset-5\n else:\n axle_x = xpos+radius+axis_offset+2.5\n follower_body = self.add_dynamic_polygon(box_polygon_shape(axle_x, axle_y-follower_len, 5, follower_len), 0, 0, filter=follower_filter)\n follower_wheel = self.add_dynamic_circle(axle_x+2.5, axle_y-radius, 5)\n self.revolving_joint(follower_wheel, follower_body, (axle_x+2.5,axle_y-radius), friction=False)\n else:\n axle_y = ypos+radius+axis_offset+2.5\n axle_x = xpos-radius\n follower_body = self.add_dynamic_polygon(box_polygon_shape(axle_x, axle_y, follower_len, 5), 0, 0, filter=follower_filter)\n follower_wheel = self.add_dynamic_circle(axle_x+radius, axle_y+2.5, 5)\n self.revolving_joint(follower_wheel, follower_body, (axle_x+radius,axle_y+2.5), friction=False)\n\n if horizontal:\n follower_body.attachment_point=(axle_x, axle_y-follower_len)\n else:\n follower_body.attachment_point=(axle_x+follower_len, axle_y)\n self.revolving_joint(attachment_body, follower_body, (axle_x+2.5,axle_y+2.5), friction=False)\n print(\"Creating cam: xpos= {}, ypos= {}, axle_x = {} ,axle_y= {}, follower_len={}\".format(xpos, ypos, axle_x, axle_y, follower_len))\n\n self.all_cam_drives.append(cam_driver)\n if axis:\n return follower_body\n else:\n return None","def blackbodyUV(temp):\n lam=lambda wl: planckian(temp, wl)\n xyz=spectrumToTristim(perfectrefl, lam)\n uvy=xyzTouvY(xyz)\n return [uvy[0], uvy[1]*2.0/3]","def process_frame(self, raw_frame, detection_all):\n \n frame = raw_frame.copy()\n h,w,_ = frame.shape\n proximity = int(h/2.4)\n pic_proximity = int(h/1.45)\n min_distance = int(w/2)\n\n head_pos = (detection_all[4][0], detection_all[4][1])\n hand_pos = (detection_all[3][0], detection_all[3][1])\n \n \n #self.target_height = target_height\n self.target_height = detection_all[4][3]\n target_width = detection_all[4][2]\n target = (detection_all[4][0], detection_all[4][1])\n\n ref_x = int(w/2)\n ref_y = int(h*0.35)\n \n self.axis_speed = self.cmd_axis_speed.copy()\n\n #Is there a Picture Command ?\n if self.picture_approach:\n cls_number = int(self.classes_dict[self.picture_target])\n print (str(self.picture_target) + 'is' + str(cls_number))\n print (self.picture_target + ' values:' + str(detection_all[cls_number]))\n \n # If no pic target found --> rotate\n if (detection_all[cls_number][0] + detection_all[cls_number][1]) == 0:\n \n log.info(f'searching for {self.picture_target}')\n \n if time.time() - self.search_start_time < 8: \n self.axis_speed[\"yaw\"] = 60\n else:\n print('stopped searching after 8 seconds')\n self.axis_speed[\"yaw\"] = 0\n self.picture_approach = False\n \n # If pic target found set as new tracking target\n else:\n print('pic target found')\n self.axis_speed[\"yaw\"] = 0\n if self.timestamp_pic_target_found is None:\n self.timestamp_pic_target_found = time.time()\n\n log.info(f'found {self.picture_target}')\n target = (detection_all[cls_number][0], detection_all[cls_number][1])\n self.target_height = detection_all[cls_number][3]\n \n #If Human Head:\n if cls_number == 4:\n self.keep_distance = pic_proximity*0.75\n else:\n self.keep_distance = pic_proximity\n\n self.pid_pitch = PID(0.15,0.0,0.1,setpoint=0,output_limits=(-30,30))\n self.tracking = True\n \n # If voice command 'come home' activate RTH\n if self.rth:\n self.target_height = detection_all[4][3]\n target_width = detection_all[4][2]\n target = (detection_all[4][0], detection_all[4][1])\n self.keep_distance = proximity*0.75\n self.toggle_tracking(tracking=True)\n\n if self.timestamp_take_picture:\n if time.time() - self.timestamp_take_picture > 2:\n self.timestamp_take_picture = None\n self.drone.take_picture()\n else:\n\n if self.tracking: \n if target != (0,0): \n if self.distance_mode: \n # Locked distance mode\n if self.keep_distance is None:\n self.keep_distance = self.target_height\n #self.graph_distance = RollingGraph(window_name=\"Distance\", y_max=500, threshold=self.keep_distance, waitKey=False)\n \n if self.palm_landing_approach:\n self.keep_distance = proximity\n self.timestamp_keep_distance = time.time()\n log.info(\"APPROACHING on pose\")\n self.pid_pitch = PID(0.2,0.0,0.1,setpoint=0,output_limits=(-30,30))\n #self.graph_distance = RollingGraph(window_name=\"Distance\", y_max=500, threshold=self.keep_distance, waitKey=False)\n\n self.body_in_prev_frame = True\n \n xoff = int(target[0]-ref_x)\n yoff = int(ref_y-target[1])\n\n #We draw an arrow from the reference point to the head we are targeting \n color = (0,0,255)\n cv2.circle(frame, (ref_x, ref_y), 10, color, 1,cv2.LINE_AA)\n cv2.line(frame, (ref_x, ref_y), target, color, 4)\n cv2.rectangle(frame, (target[0]-target_width//2, target[1]-self.target_height//2), \n (target[0]+target_width//2, target[1]+self.target_height//2),color,4)\n \n # The PID controllers calculate the new speeds for yaw and throttle\n self.axis_speed[\"yaw\"] = int(-self.pid_yaw(xoff))\n #log.debug(f\"xoff: {xoff} - speed_yaw: {self.axis_speed['yaw']}\")\n self.last_rotation_is_cw = self.axis_speed[\"yaw\"] > 0\n\n self.axis_speed[\"throttle\"] = int(-self.pid_throttle(yoff))\n #log.debug(f\"yoff: {yoff} - speed_throttle: {self.axis_speed['throttle']}\")\n\n #If in locked distance mode\n if self.keep_distance and self.target_height: \n \n # Check RTH\n if self.rth and self.target_height>=self.keep_distance:\n self.rth = False\n \n elif self.palm_landing_approach and self.target_height>self.keep_distance:\n # The drone is now close enough to the body\n # Let's do the palm landing\n log.info(\"PALM LANDING after approaching\")\n self.palm_landing_approach = False\n self.toggle_tracking(tracking=False)\n self.palm_land() \n \n elif self.picture_approach and \\\n abs(self.target_height-self.keep_distance) < 15 and \\\n xoff < 12 and yoff < 15:\n \n # The drone is now close enough to the pic target\n # Let's take a picture \n self.toggle_tracking(tracking=False)\n print('take a picture')\n self.drone.take_picture()\n self.picture_approach = False\n self.timestamp_pic_target_found = None\n self.pid_pitch = PID(0.3,0.0,0.1,setpoint=0,output_limits=(-70,70))\n \n \n else:\n self.axis_speed[\"pitch\"] = int(self.pid_pitch(self.target_height-self.keep_distance))\n log.debug(f\"Target distance: {self.keep_distance} - cur: {self.target_height} -speed_pitch: {self.axis_speed['pitch']}\")\n \n if abs(head_pos[1] - hand_pos[1])<30:\n if self.timestamp_hand_ctrl is None:\n self.timestamp_hand_ctrl = time.time()\n if time.time() - self.timestamp_hand_ctrl > 1:\n if self.head_hand_x_dist is None:\n self.head_hand_x_ref = head_pos[0]-hand_pos[0]\n \n self.hand_ctrl = True\n self.head_hand_x_dist = head_pos[0]-hand_pos[0]\n self.axis_speed[\"roll\"] = int(-self.pid_roll(self.head_hand_x_ref - self.head_hand_x_dist))\n #print (f'head hand X distance: {abs(head_pos[0]-hand_pos[0])}')\n\n else:\n self.hand_ctrl = False\n self.timestamp_hand_ctrl = None\n self.head_hand_x_dist = None\n\n else: # Tracking but no body detected\n if self.body_in_prev_frame:\n self.timestamp_no_body = time.time()\n self.body_in_prev_frame = False\n self.axis_speed[\"throttle\"] = self.prev_axis_speed[\"throttle\"]\n self.axis_speed[\"yaw\"] = self.prev_axis_speed[\"yaw\"]\n else:\n if time.time() - self.timestamp_no_body < 1:\n print(\"NO BODY SINCE < 1\", self.axis_speed, self.prev_axis_speed)\n self.axis_speed[\"throttle\"] = self.prev_axis_speed[\"throttle\"]\n self.axis_speed[\"yaw\"] = self.prev_axis_speed[\"yaw\"]\n else:\n log.debug(\"NO BODY detected for 1s -> rotate\")\n self.axis_speed[\"yaw\"] = self.def_speed[\"yaw\"] * (1 if self.last_rotation_is_cw else -1)\n \n\n # Send axis commands to the drone\n for axis, command in self.axis_command.items():\n if self.axis_speed[axis]is not None and self.axis_speed[axis] != self.prev_axis_speed[axis]:\n #log.debug(f\"COMMAND {axis} : {self.axis_speed[axis]}\")\n command(self.axis_speed[axis])\n self.prev_axis_speed[axis] = self.axis_speed[axis]\n else:\n # This line is necessary to display current values in 'self.write_hud'\n self.axis_speed[axis] = self.prev_axis_speed[axis]\n \n # Write the HUD on the frame\n frame = self.write_hud(frame)\n\n return frame","def generate_sphere_full():\n \n num_voxels = 31\n c = (15.0, 15.0, 15.0)\n\n data_x = []\n data_y = []\n data_z = []\n data_intensity = []\n\n volume = numpy.zeros((num_voxels, num_voxels, num_voxels))\n\n for x in range(num_voxels):\n for y in range(num_voxels):\n for z in range(num_voxels):\n\n if numpy.sqrt((x-c[0])**2 + (y-c[1])**2 + (z-c[2])**2) - 7.5 < 1.5:\n data_x.append(x)\n data_y.append(y)\n data_z.append(z)\n data_intensity.append(200.0)\n\n volume[x,y,z] = 200.0\n\n\n return data_x, data_y, data_z, data_intensity, volume","def FL_2_mav_gps(self, data):\n\n\n\n #Data treatment\n messagedata = [\n int(data['simulation/sim-time-sec']*self._sec2usec), #time_usec boot time usec int\n 3, #Fix_type uint8_t\t0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.\n int(data['position/lat-gc-rad']*self._rad2degE7), # lat 10e7.deg int\n int(data['position/long-gc-rad']*self._rad2degE7), # lon 10e7.deg int\n int(data['position/h-sl-ft']*self._ft2m*self._m2mm), # alt mm int\n 65535, #eph uint16_t\tGPS HDOP horizontal dilution of position in cm (m*100). If unknown, set to: 65535\n 65535, #epv\tuint16_t\tGPS VDOP vertical dilution of position in cm (m*100). If unknown, set to: 65535\n 65535, #uint16_t\tGPS ground speed (m/s * 100). If unknown, set to: 65535\n int(data['velocities/v-north-fps']*self._ft2m*self._m2cm),# vn cm.s-1 int\n int(data['velocities/v-east-fps']*self._ft2m*self._m2cm), # ve cm.s-1 int\n int(data['velocities/v-down-fps']*self._ft2m*self._m2cm), # vd cm.s-1 int\n 65535, #cog\tuint16_t\tCourse over ground (NOT heading, but direction of movement) in degrees * 100, 0.0..359.99 degrees. If unknown, set to: 65535\n 255, #satellites_visible\tuint8_t\tNumber of satellites visible. If unknown, set to 255\n ]\n\n return messagedata","def testCalspecMags(self):\n std = MKIDStd.MKIDStd()\n bFilter = std.filters['B']\n vFilter = std.filters['V']\n\n # BD17\n bd17Flux = std.load(\"bd17\")\n B = std.getVegaMag(bd17Flux, bFilter)\n V = std.getVegaMag(bd17Flux, vFilter)\n self.assertAlmostEqual(B-V, 0.44, places=1, msg=\"value=%f\"%B)\n self.assertAlmostEqual(B, 9.47, places=0, msg=\"value=%f\"%B)","def Magnus4(self,direction='x'):\n self.reset()\n self.mol.orthoDen()\n self.mol.orthoFock()\n h = -1j*self.stepsize\n for idx,time in enumerate((self.time)):\n if direction.lower() == 'x':\n self.mol.computeDipole()\n self.dipole.append(np.real(self.mol.mu[0]))\n elif direction.lower() == 'y':\n self.mol.computeDipole()\n self.dipole.append(np.real(self.mol.mu[1]))\n elif direction.lower() == 'z':\n self.mol.computeDipole()\n self.dipole.append(np.real(self.mol.mu[2]))\n # record pulse envelope for later plotting, etc.\n self.shape.append(self.pulse(time))\n curDen = np.copy(self.mol.PO)\n \n self.addField(time + 0.0*self.stepsize,direction=direction)\n k1 = h*self.mol.FO \n Q1 = k1\n U = expm(0.5*Q1)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n \n self.addField(time + 0.5*self.stepsize,direction=direction)\n k2 = h*self.mol.FO\n Q2 = k2 - k1\n U = expm(0.5*Q1 + 0.25*Q2)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n\n self.addField(time + 0.5*self.stepsize,direction=direction)\n k3 = h*self.mol.FO\n Q3 = k3 - k2\n U = expm(Q1 + Q2)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n\n self.addField(time + 1.0*self.stepsize,direction=direction)\n k4 = h*self.mol.FO\n Q4 = k4 - 2*k2 + k1\n L = 0.5*Q1 + 0.25*Q2 + (1/3.)*Q3 - (1/24.)*Q4\n L += -(1/48.)*self.mol.comm(Q1,Q2)\n U = expm(L)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n \n self.addField(time + 0.5*self.stepsize,direction=direction)\n k5 = h*self.mol.FO\n Q5 = k5 - k2 \n L = Q1 + Q2 + (2/3.)*Q3 + (1/6.)*Q4 - (1/6.)*self.mol.comm(Q1,Q2)\n U = expm(L)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n \n self.addField(time + 1.0*self.stepsize,direction=direction)\n k6 = h*self.mol.FO\n Q6 = k6 -2*k2 + k1\n L = Q1 + Q2 + (2/3.)*Q5 + (1/6.)*Q6\n L += -(1/6.)*self.mol.comm(Q1, (Q2 - Q3 + Q5 + 0.5*Q6))\n\n U = expm(L)\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \n self.mol.updateFock()\n \n # density and Fock are done updating, wrap things up\n self.mol.unOrthoFock() \n self.mol.unOrthoDen() \n self.mol.computeEnergy()\n self.Energy.append(np.real(self.mol.energy))","def FL_2_mav_state(self, data):\n\n (data['velocities/phidot-rad_sec_bf'],\n data['velocities/thetadot-rad_sec_bf'],\n data['velocities/psidot-rad_sec_bf']) = self.convert_body_frame(\n data['attitude/phi-rad'],\n data['attitude/theta-rad'],\n data['velocities/phidot-rad_sec'],\n data['velocities/thetadot-rad_sec'],\n data['velocities/psidot-rad_sec']\n )\n\n # Data treatment\n message_data = [\n 1000000000,\n # int(data['simulation/sim-time-sec']*cls._sec2usec), # time usec\n data['attitude/phi-rad'], # phi rad float\n data['attitude/theta-rad'], # theta rad float\n data['attitude/psi-rad'], # psi rad float\n data['velocities/phidot-rad_sec'], # rollspeed rad.s-1 float\n data['velocities/thetadot-rad_sec'], # pitchspeed rad.s-1 float\n data['velocities/psidot-rad_sec'], # yawspeed rad.s-1 float\n int(data['position/lat-gc-rad']*self._rad2degE7), # lat 10e7.deg int\n int(data['position/long-gc-rad']*self._rad2degE7), # lon 10e7.deg int\n int(data['position/h-sl-ft']*self._ft2m*self._m2mm), # alt mm int\n int(data['velocities/v-north-fps']*self._ft2m*self._m2cm), # vx cm.s-1 int\n int(data['velocities/v-east-fps']*self._ft2m*self._m2cm), # vy cm.s-1 int\n int(data['velocities/v-down-fps']*self._ft2m*self._m2cm), # vz cm.s-1 int\n int(data['accelerations/udot-ft_sec2']*self._ft2m*self._mpss2mg), # xacc 1000/g int\n int(data['accelerations/vdot-ft_sec2']*self._ft2m*self._mpss2mg), # yacc 1000/g int\n int(data['accelerations/wdot-ft_sec2']*self._ft2m*self._mpss2mg) # zacc 1000/g int\n ]\n return message_data","def Motion_estimate_compute_1frame(ref1_frame,ref2_frame,target_frame,block_size):\n\n ref_Y, ref_U, ref_V = [], [], []\n for ref_frame in [ref1_frame,ref2_frame]:\n ref_Y.append(np.array(ref_frame[ :sep1]).reshape(height,width))\n ref_U.append(np.array(ref_frame[sep1:sep2]).reshape(height//2,width//2))\n ref_V.append(np.array(ref_frame[sep2: ]).reshape(height//2,width//2))\n \n tar_Y = target_frame[ :sep1].reshape(height,width)\n tar_U = target_frame[sep1:sep2].reshape(height//2,width//2)\n tar_V = target_frame[sep2: ].reshape(height//2,width//2)\n \n err_Y = np.array(tar_Y)\n err_U = np.array(tar_U)\n err_V = np.array(tar_V)\n vect_field = np.zeros((height//block_size,width//block_size,3),dtype=int)\n \n for X in range(0,height//block_size):\n for Y in range(0,width//block_size):\n xa, xz = X*block_size,(X+1)*block_size\n ya, yz = Y*block_size,(Y+1)*block_size\n # Find the motion vector for the block XY\n \n ref,vx,vy = Motion_estimate_compute_P_1block(ref_Y[0],ref_Y[1],\n tar_Y[xa:xz,ya:yz],\n [xa,ya])\n \n vect_field[X,Y,:] = np.array([ref,vx,vy])\n \n pxa, pxz = xa+vx,xz+vx\n pya, pyz = ya+vy,yz+vy\n \n patch_Y = ref_Y[ref][pxa:pxz,pya:pyz]\n patch_U = ref_U[ref][pxa//2:pxz//2,pya//2:pyz//2]\n patch_V = ref_V[ref][pxa//2:pxz//2,pya//2:pyz//2]\n \n err_Y[xa:xz,ya:yz] -= patch_Y\n err_U[xa//2:xz//2,ya//2:yz//2] -= patch_U\n err_V[xa//2:xz//2,ya//2:yz//2] -= patch_V\n \n frame_error = np.concatenate((err_Y.flatten(),\n err_U.flatten(),\n err_V.flatten()))\n dct_error = DCT_compute(frame_error,offset=0,Q='opti') # Error -> mean = 0\n # -> offset =0\n \n P_frame = np.concatenate((vect_field.flatten(),dct_error.flatten()))\n \n return P_frame","def blockDetector(self, frame):\n self.detectBlocksInDepthImage()\n self.block_pos = np.zeros((50,3))\n self.block_num = 0\n pixal_arm = np.zeros(2)\n if self.kinectCalibrated == True:\n # get current arm position\n real_arm_x, real_arm_y,_,_ = self.rexarm.get_wrist_pose()\n real_arm_x *= -1000\n real_arm_y *= 1000\n real_arm = np.array(([real_arm_x],[real_arm_y],[1]))\n \n # normalize arm_line vector\n arm_length = np.sqrt(real_arm_x**2 + real_arm_y**2)\n l = np.array([real_arm_x,real_arm_y])\n\n # find center of block_1_height and put them into block_position\n for cnt in self.block_contours:\n M = cv2.moments(cnt)\n if M['m00']>0:\n cx = int(M['m10']/M['m00'])\n cy = int(M['m01']/M['m00'])\n c = np.array([[cx],[cy]])\n # Eliminate Arm itself\n real_x = self.real_coord[cx][cy][0]\n real_y = self.real_coord[cx][cy][1]\n d = np.linalg.norm(np.cross(l, np.array([real_x,real_y])))/np.linalg.norm(l)\n \n d_to_arm = np.sqrt((real_x-real_arm_x)**2+(real_y-real_arm_y)**2)\n d_to_ori = np.sqrt(real_x**2 + real_y**2)\n\n \n if d > 2 and not(d_to_ori<arm_length and d_to_arm<arm_length):\n # Check if its in our ROI\n if self.real_coord[cx][cy][0]>self.real_points[0][0] and self.real_coord[cx][cy][0]<self.real_points[2][0]:\n if self.real_coord[cx][cy][1]<self.real_points[0][1] and self.real_coord[cx][cy][1]>self.real_points[2][1]:\n # points\n self.block_pos[self.block_num][0] = self.real_coord[cx][cy][0]\n self.block_pos[self.block_num][1] = self.real_coord[cx][cy][1]\n self.block_pos[self.block_num][2] = 1\n # orientation\n rect = cv2.minAreaRect(cnt)\n self.block_ori[self.block_num][0] = -rect[2]\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n # detect color\n self.block_color[self.block_num] = self.colorDetector(cx,cy)\n # draw contours\n cv2.drawContours(self.currentDetectFrame,[box],0,(30,145,86),3)\n cv2.circle(self.currentDetectFrame,(cx,cy),5,(30,145,86),-1)\n self.block_num += 1\n\n # find centers of 2 blocks\n for cnt in self.block_contours_2:\n M = cv2.moments(cnt)\n if M['m00']>0:\n cx = int(M['m10']/M['m00'])\n cy = int(M['m01']/M['m00'])\n c = np.array([[cx],[cy]])\n # Eliminate Arm itself\n real_x = self.real_coord[cx][cy][0]\n real_y = self.real_coord[cx][cy][1]\n d = np.linalg.norm(np.cross(l, np.array([real_x,real_y])))/np.linalg.norm(l)\n \n d_to_arm = np.sqrt((real_x-real_arm_x)**2+(real_y-real_arm_y)**2)\n d_to_ori = np.sqrt(real_x**2 + real_y**2)\n \n \n if d > 2 and not(d_to_ori<arm_length and d_to_arm<arm_length):\n # Check if its in our ROI\n if self.real_coord[cx][cy][0]>self.real_points[0][0] and self.real_coord[cx][cy][0]<self.real_points[2][0]:\n if self.real_coord[cx][cy][1]<self.real_points[0][1] and self.real_coord[cx][cy][1]>self.real_points[2][1]:\n # points\n self.block_pos[self.block_num][0] = self.real_coord[cx][cy][0]\n self.block_pos[self.block_num][1] = self.real_coord[cx][cy][1]\n self.block_pos[self.block_num][2] = 2\n # orientation\n rect = cv2.minAreaRect(cnt)\n self.block_ori[self.block_num][0] = -rect[2]\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n # detect color\n self.block_color[self.block_num] = self.colorDetector(cx,cy)\n # draw contours\n cv2.drawContours(self.currentDetectFrame,[box],0,(30,87,137),3)\n cv2.circle(self.currentDetectFrame,(cx,cy),5,(30,87,137),-1)\n self.block_num += 1 \n\n # find centers of 3 blocks\n for cnt in self.block_contours_3:\n M = cv2.moments(cnt)\n if M['m00']>0:\n cx = int(M['m10']/M['m00'])\n cy = int(M['m01']/M['m00'])\n c = np.array([[cx],[cy]])\n # Eliminate Arm itself\n real_x = self.real_coord[cx][cy][0]\n real_y = self.real_coord[cx][cy][1]\n d = np.linalg.norm(np.cross(l, np.array([real_x,real_y])))/np.linalg.norm(l)\n \n d_to_arm = np.sqrt((real_x-real_arm_x)**2+(real_y-real_arm_y)**2)\n d_to_ori = np.sqrt(real_x**2 + real_y**2)\n \n \n if d > 2 and not(d_to_ori<arm_length and d_to_arm<arm_length):\n # Check if its in our ROI\n if self.real_coord[cx][cy][0]>self.real_points[0][0] and self.real_coord[cx][cy][0]<self.real_points[2][0]:\n if self.real_coord[cx][cy][1]<self.real_points[0][1] and self.real_coord[cx][cy][1]>self.real_points[2][1]:\n # points\n self.block_pos[self.block_num][0] = self.real_coord[cx][cy][0]\n self.block_pos[self.block_num][1] = self.real_coord[cx][cy][1]\n self.block_pos[self.block_num][2] = 3\n # orientation\n rect = cv2.minAreaRect(cnt)\n self.block_ori[self.block_num][0] = -rect[2]\n box = cv2.boxPoints(rect)\n box = np.int0(box)\n # detect color\n self.block_color[self.block_num] = self.colorDetector(cx,cy)\n # draw contours\n cv2.drawContours(self.currentDetectFrame,[box],0,(204,6,6),3)\n cv2.circle(self.currentDetectFrame,(cx,cy),5,(204,6,6),-1)\n self.block_num += 1 \n self.block_pos[self.block_num:50] = 0\n self.block_ori[self.block_num:50] = 0\n\n return frame"],"string":"[\n \"def compute_magnetic_field(self, coords, params={}, basis=\\\"rpz\\\"):\",\n \"def get_probeLocs_calib_setup_cm(dir, num_probes = 16):\\n position_vectors = [[0] * 3 for i in range(num_probes)]\\n\\n #every x postion\\n\\n # Convert to meters\\n x_pos = [-4.25*2.54, -4.25*2.54, 4.24*2.54, 4.24*2.54]\\n y_pos = [-4.25*2.54, 4.24*2.54, 4.24*2.54, -4.25*2.54]\\n z_pos = [-2.25*2.54, -0.75*2.54, 0.75*2.54, 2.25*2.54]\\n x = 0\\n for i in range(num_probes):\\n if(i%4 ==0 and i>0):\\n x+=1\\n position_vectors[i][0] =x_pos[x]\\n position_vectors[i][1] = y_pos[x]\\n position_vectors[i][2] =z_pos[i%4]\\n # print(position_vectors[i][0])\\n\\n \\\"\\\"\\\" Now take into account the direction\\n r shots : x,y,z - > r,t,z\\n t shots : x,y,z - > r,t,z\\n z shots : x,y,z - > r,t,z\\n \\\"\\\"\\\"\\n if dir ==2 :#r\\n # don't need to switch anything\\n return position_vectors\\n if dir == 0:#t\\n # looks like -90 degree rotation about y-axis of probe coil orientation, so switch x and z\\n position_vectors[:][0], position_vectors[:][2] = position_vectors[:][2], position_vectors[:][0]\\n return position_vectors\\n if dir ==1:#z\\n # also like -90 degree rotation, switch x and z\\n position_vectors[:][0], position_vectors[:][2] = position_vectors[:][2], position_vectors[:][0]\\n return position_vectors\\n\\n return position_vectors\",\n \"def get_probeLocs_calib_setup(dir, num_probes = 16):\\n position_vectors = [[0] * 3 for i in range(num_probes)]\\n\\n #every x postion\\n\\n # Convert to meters\\n x_pos = [-4.25*1e-3*25.4, -4.25*1e-3*25.4, 4.24*1e-3*25.4, 4.24*1e-3*25.4]\\n y_pos = [-4.25*1e-3*25.4, 4.24*1e-3*25.4, 4.24*1e-3*25.4, -4.25*1e-3*25.4]\\n z_pos = [-2.25*1e-3*25.4, -0.75*1e-3*25.4, 0.75*1e-3*25.4, 2.25*1e-3*25.4]\\n x = 0\\n for i in range(num_probes):\\n if(i%4 ==0 and i>0):\\n x+=1\\n position_vectors[i][0] =x_pos[x]\\n position_vectors[i][1] = y_pos[x]\\n position_vectors[i][2] =z_pos[i%4]\\n # print(position_vectors[i][0])\\n\\n \\\"\\\"\\\" Now take into account the direction\\n r shots : x,y,z - > r,t,z\\n t shots : x,y,z - > r,t,z\\n z shots : x,y,z - > r,t,z\\n \\\"\\\"\\\"\\n if dir ==2 :#r\\n # don't need to switch anything\\n return position_vectors\\n if dir == 0:#t\\n # looks like -90 degree rotation about y-axis of probe coil orientation, so switch x and z\\n position_vectors[:][0], position_vectors[:][2] = position_vectors[:][2], position_vectors[:][0]\\n return position_vectors\\n if dir ==1:#z\\n # also like -90 degree rotation, switch x and z\\n position_vectors[:][0], position_vectors[:][2] = position_vectors[:][2], position_vectors[:][0]\\n return position_vectors\\n\\n return position_vectors\",\n \"def calcMagneticFieldMap(self):\\n # Normalised b-field (note lower case)\\n self.solenoid.calcMagneticFieldMap()\\n self.b = lambda z: self.solenoid.B_interp(z) * -e / (2 * m * c)\\n self.calc_level = CALC_B_MAP\",\n \"def get_x_y_z(drone, p, q, r):\\n num_cameras = 2\\n camera_constants = [0,math.pi/2]\\n rads = np.zeros(num_cameras)\\n phis = np.zeros(num_cameras)\\n d = np.zeros(num_cameras)\\n theta = np.zeros(num_cameras)\\n Hs = np.zeros(num_cameras)\\n s = 12\\n HFOV = math.pi/4\\n VFOV = 5*math.pi/36\\n HPIX = 1280\\n VPIX = 720\\n #loop one, where we increment over camera number, and\\n # get new information\\n\\n cent = calculate_centroid(p,q,r)\\n for camera_num in range(num_cameras):\\n\\n A,B = find_a_and_b(p[camera_num],q[camera_num],r[camera_num],cent[camera_num])\\n a = find_a(A,B)\\n d_in = find_inner_d(a, s)\\n angle_c = find_angle_c(a)\\n alpha = find_alpha(HFOV, HPIX, A)\\n w = find_w(angle_c, s)\\n d_out = find_outer_d(w,alpha,a)\\n pointy_front = is_point_front(r[camera_num],q[camera_num],p[camera_num],cent[camera_num])\\n d[camera_num] = find_d(d_in,d_out,pointy_front)\\n theta[camera_num] = find_theta(angle_c,A,B,camera_constants[camera_num])\\n k = find_k(drone[camera_num], cent[camera_num])\\n angle_k = find_angle_k(k, HFOV, HPIX)\\n phi = find_phi(theta[camera_num], angle_k)\\n rad = find_r(d[camera_num], angle_k)\\n phis[camera_num] = phi\\n rads[camera_num] = rad\\n\\n # end of first loop\\n\\n cosphis = np.cos(phis)\\n sinphis = np.sin(phis)\\n big_matrix = np.column_stack((cosphis,sinphis))\\n points = np.zeros((int(num_cameras*(num_cameras-1)/2),2))\\n i = 0\\n for pair in itertools.combinations(range(num_cameras), 2):\\n matrix_a = np.vstack((big_matrix[pair[0]],big_matrix[pair[1]]))\\n vec_b = np.hstack((rads[pair[0]],rads[pair[1]]))\\n point = np.linalg.solve(matrix_a, vec_b)\\n points[i] = point\\n i += 1\\n drone_pos = np.mean(points,axis=0)\\n\\n # start of third loop\\n for camera_num in range(num_cameras):\\n d_prime = find_d_prime(d[camera_num], theta[camera_num], drone_pos)\\n P,Q,M,N = find_P_Q_M_N(p[camera_num],q[camera_num],r[camera_num])\\n h = find_h(d[camera_num],P,Q,M,N)\\n angle_4 = find_angle_4(h,d[camera_num])\\n Y = find_Y(drone[camera_num], cent[camera_num])\\n angle_5 = find_angle_5(Y, VFOV, VPIX)\\n angle_6 = angle_5 - angle_4\\n h_prime = find_h_prime(d_prime, angle_6)\\n Hs[camera_num] = h + h_prime\\n drone_h = np.mean(H)\\n return np.append(drone_pos,drone_h)\",\n \"def field ( self , xyz ) :\\n return self._ilhcbmagnet.fieldVector ( xyz )\",\n \"def normal_vectors(ATOM_list, frame, number_of_atoms, number_of_molecules, number_of_vectors, centerlist, referencelist, boxX, boxY, boxZ):\\t\\n\\tNORMAL_VECTORS_out=open(\\\"normalvectors.xyz\\\",'a')\\n\\t\\n\\tNORMAL_VECTORS_check=open(\\\"check_normalvectors.xyz\\\",'a')\\n\\t\\n\\tANGLEDIST_VECTORS_out=open(\\\"angle_dist_vectors.xyz\\\",'a')\\n\\t\\n\\t\\n\\tVorzugsrichtung_out=open(\\\"sum_over_all_normalvectors.dat\\\",'a')\\n\\t\\n\\t\\n\\t\\n\\tNORMAL_VECTORS_check.write(str( (number_of_vectors*(2 + int(len(referencelist))) )*number_of_molecules )+'\\\\n')\\n\\tNORMAL_VECTORS_check.write(str(frame)+'\\\\n')\\n\\t\\n\\tNORMAL_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\\\n')\\n\\tNORMAL_VECTORS_out.write(str(frame)+'\\\\n')\\n\\n\\tANGLEDIST_VECTORS_out.write(str( (number_of_vectors*2)*number_of_molecules )+'\\\\n')\\n\\tANGLEDIST_VECTORS_out.write(str(frame)+'\\\\n')\\n\\t\\n\\tvorzugsvektor = np.asarray([0,0,0])\\n\\treference=0\\n\\t\\n\\t\\n\\tfor l in range(0,number_of_molecules):\\n\\t\\tfor vec_count in range(0,number_of_vectors):\\n\\t\\t\\tr = []\\n\\t\\t\\t#get the 'middle' of the DPI molecule\\n\\t\\t\\t\\n\\t\\t\\n\\t\\t\\t#get geometric center\\n\\t\\t\\tcenter=np.asarray([0,0,0])\\n\\t\\t\\t#append all vectors defining the center\\n\\t\\t\\tfor i in range(len(centerlist[vec_count])):\\n\\t\\t\\t\\t# x y z\\n\\t\\t\\t\\tr.append( np.asarray( [ ATOM_list[centerlist[vec_count][i] + reference][1],ATOM_list[centerlist[vec_count][i] + reference][2],ATOM_list[centerlist[vec_count][i] + reference][3] ] ) ) \\n\\t\\t\\t\\tcenter = center + r[i]\\n\\t\\t\\tcenter = center / len(centerlist[vec_count])\\n\\t\\t\\n\\t\\t\\t#calculate all reference vectors\\n\\t\\t\\tr=[]\\n\\t\\t\\tfor i in range(len(referencelist[vec_count])):\\n\\t\\t\\t\\tr.append(np.asarray( [ ATOM_list[referencelist[vec_count][i] + reference][1],ATOM_list[referencelist[vec_count][i] + reference][2],ATOM_list[referencelist[vec_count][i] + reference][3] ] ) )\\n\\t\\t\\n\\t\\t\\t#get the cross products\\n\\t\\t\\tnormal_vec= np.asarray([0,0,0])\\n\\t\\t\\tfor i in range(len(r)):\\n\\t\\t\\t\\tif (i<(len(r)-1)):\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tif ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]+boxX) ) and ( abs(r[i][0]-center[0]) < abs(r[i][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]\\n\\t\\t\\t\\t\\telif (abs(r[i][0]-center[0]+boxX) < abs(r[i][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]+boxX\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdx = r[i][0]-center[0]-boxX\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]+boxY) ) and ( abs(r[i][1]-center[1]) < abs(r[i][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\telif (abs(r[i][1]-center[1]+boxY) < abs(r[i][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]+boxY\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdy = r[i][1]-center[1]-boxY\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]+boxZ) ) and ( abs(r[i][2]-center[2]) < abs(r[i][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\telif (abs(r[i][2]-center[2]+boxZ) < abs(r[i][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]+boxZ\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdz = r[i][2]-center[2]-boxZ\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]+boxX) ) and ( abs(r[i+1][0]-center[0]) < abs(r[i+1][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][0]-center[0]+boxX) < abs(r[i+1][0]-center[0]-boxX) ):\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]+boxX\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdx2 = r[i+1][0]-center[0]-boxX\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]+boxY) ) and ( abs(r[i+1][1]-center[1]) < abs(r[i+1][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][1]-center[1]+boxY) < abs(r[i+1][1]-center[1]-boxY) ):\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]+boxY\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdy2 = r[i+1][1]-center[1]-boxY\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tif ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]+boxZ) ) and ( abs(r[i+1][2]-center[2]) < abs(r[i+1][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]\\n\\t\\t\\t\\t\\telif (abs(r[i+1][2]-center[2]+boxZ) < abs(r[i+1][2]-center[2]-boxZ) ):\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]+boxZ\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tdz2 = r[i+1][2]-center[2]-boxZ\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tvec1=np.asarray([dx,dy,dz])\\n\\t\\t\\t\\t\\tvec2=np.asarray([dx2,dy2,dz2])\\n\\t\\t\\t\\t\\t#dy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\t#dz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\\n\\t\\t\\t\\t\\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm( np.cross(vec1, vec2) )\\n\\t\\t\\t\\telif ( i==len(r) ):\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t#minimum image convenction\\n\\t\\t\\t\\t\\tdx = min( abs(r[i][0]-center[0]), abs(r[i][0]-center[0]+boxX), abs(r[i][0]-center[0]-boxX) )\\n\\t\\t\\t\\t\\tdy = min( abs(r[i][1]-center[1]), abs(r[i][1]-center[1]+boxX), abs(r[i][1]-center[1]-boxX) )\\n\\t\\t\\t\\t\\tdz = min( abs(r[i][2]-center[2]), abs(r[i][2]-center[2]+boxX), abs(r[i][2]-center[2]-boxX) )\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tdx2 = min( abs(r[0][0]-center[0]), abs(r[0][0]-center[0]+boxX), abs(r[0][0]-center[0]-boxX) )\\n\\t\\t\\t\\t\\tdy2 = min( abs(r[0][1]-center[1]), abs(r[0][1]-center[1]+boxX), abs(r[0][1]-center[1]-boxX) )\\n\\t\\t\\t\\t\\tdz2 = min( abs(r[0][2]-center[2]), abs(r[0][2]-center[2]+boxX), abs(r[0][2]-center[2]-boxX) )\\n\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t\\tvec1=np.asarray([dx,dy,dz])\\n\\t\\t\\t\\t\\tvec2=np.asarray([dx2,dy2,dz2])\\n\\t\\t\\t\\t\\t#dy = r[i][1]-center[1]\\n\\t\\t\\t\\t\\t#dz = r[i][2]-center[2]\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[i+1]-center)\\n\\t\\t\\t\\t\\tnormal_vec = normal_vec + np.cross(vec1, vec2)/np.linalg.norm(np.cross(vec1, vec2))\\n\\t\\t\\t\\t\\t#normal_vec = normal_vec + np.cross(r[i]-center, r[0]-center) \\n\\t\\t\\n\\t\\t\\t#normalize\\n\\t\\t\\tnormal_vec = normal_vec/np.linalg.norm(normal_vec)\\n\\t\\t\\n\\t\\t\\t#\\t#direction vectors\\n\\t\\t\\t#\\tdir_vec1 = np.asarray([r[6][0],r[6][1],r[6][2]])\\n\\t\\t\\t#\\tdir_vec2 = np.asarray([r[7][0],r[7][1],r[7][2]])\\n\\t\\t\\t#\\tdir_vec3 = np.asarray([r[8][0],r[8][1],r[8][2]])\\n\\t\\t\\t#\\tdir_vec4 = np.asarray([r[9][0],r[9][1],r[9][2]])\\n\\t\\t\\t#\\tdir_vec = (dir_vec1 + dir_vec2 + dir_vec3 + dir_vec4)/4.0\\n\\t\\t\\t#\\tdir_vec = mittelpunkt_dpi - dir_vec\\t\\t\\t\\n\\n\\t\\t\\t#change direction according to bending\\n\\t\\t\\t#\\tif normal_vec[0]!=0 and dir_vec[0]!=0:\\n\\t\\t\\t#\\t\\tif normal_vec[0]/abs(normal_vec[0])!=dir_vec[0]/abs(dir_vec[0]):\\n\\t\\t\\t#\\t\\t\\tnormal_vec[0] = -normal_vec[0]\\n\\t\\t\\t#\\tif normal_vec[1]!=0 and dir_vec[1]!=0:\\n\\t\\t#\\t\\t\\tif normal_vec[1]/abs(normal_vec[1])!=dir_vec[1]/abs(dir_vec[1]):\\n\\t\\t#\\t\\t\\t\\tnormal_vec[1] = -normal_vec[1]\\n\\t\\t#\\t\\tif normal_vec[2]!=0 and dir_vec[2]!=0:\\n\\t\\t#\\t\\t\\tif normal_vec[2]/abs(normal_vec[2])!=dir_vec[2]/abs(dir_vec[2]):\\n\\t\\t#\\t\\t\\t\\tnormal_vec[2] = -normal_vec[2]\\n\\n\\t\\t\\t\\n\\t\\t\\t#check for a vorzugsvektor\\n\\t\\t\\tvorzugsvektor = vorzugsvektor + normal_vec\\n\\t\\t\\tNORMAL_VECTORS_out.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_out.write('O' +'\\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tANGLEDIST_VECTORS_out.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tANGLEDIST_VECTORS_out.write('H' +'\\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('C' +'\\t'+ str((center)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('O' +'\\t'+ str((center+normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tNORMAL_VECTORS_check.write('H' +'\\t'+ str((normal_vec)).replace('[', '').replace(']','')+ '\\\\n')\\n\\t\\t\\tfor i in range(len(referencelist[vec_count])):\\n\\t\\t\\t\\tNORMAL_VECTORS_check.write('N' +'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][1])+'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][2])+'\\t'+ str(ATOM_list[referencelist[vec_count][i] + reference][3])+ '\\\\n')\\n\\n\\t\\t#always skip 1 entire molecule forward\\n\\t\\treference=reference + number_of_atoms/number_of_molecules\\n\\t\\t\\n\\t#calculate a vorzugsvektor as sum over DIPBI normal vectors divided by number of DPBI vectors\\n\\tvorzugsvektor = vorzugsvektor/(number_of_vectors*frames*number_of_molecules)\\n\\tVorzugsrichtung_out.write(str(frame) + ' ' + str((vorzugsvektor)).replace('[', '').replace(']','')+'\\\\n')\\n\\tNORMAL_VECTORS_out.close()\\n\\tNORMAL_VECTORS_check.close()\\n\\treturn\",\n \"def find_point(ball_loc, direction, kick_positions, positions):\\n # unpack leg positions\\n kick_x, kick_y, kick_z = kick_positions\\n pos_x, pos_y, pos_z = positions \\n # ball position relative to the kicking foot\\n ball_loc = [100, -100.55154471, 0.09521921 ]\\n # all boundaries for the kicking leg\\n min_x = int(kick_positions[0] - 75) #- 0.13641\\n max_x = int(kick_positions[0] +75)\\n #min_y = int(kick_positions[1] - 75) #0.1340\\n #max_y = int(kick_positions[1] + 75)#0.1014\\n min_y = -140\\n max_y = -90\\n #min_z = int(kick_positions[2] ) #0.05\\n #max_z = int(kick_positions[2] + 50) #0.1526\\n min_z = 40\\n max_z = 75\\n\\n # make ball position in world_space coordinates\\n bal_x = ball_loc[0]\\n bal_y = ball_loc[1]\\n bal_z = ball_loc[2]\\n # make direction in world_space coordinates\\n #direction_x = kick_x + direction[0]\\n #direction_y = kick_y + direction[1]\\n #direction_z = kick_z + direction[2]\\n direction = np.matrix([ [direction[0]], [direction[1]], [direction[2]]])\\n # no retraction when other leg is there(change these values)\\n #if( pos_y < max_y or pos_y > min_y):\\n # if( abs(pos_y - max_y) > abs(pos_y - min_y)):\\n # min_y = pos_y\\n # else:\\n # max_y = pos_y\\n best_pos = 0\\n # make matrix of the world_space ball and direction coordinates\\n bal_loc = np.matrix([[bal_x], [bal_y], [bal_z]])\\n #direction = np.matrix([[direction_x], [direction_y], [direction_z]])\\n for x in xrange(min_x, max_x, 10):\\n for y in xrange(min_y, max_y, 10):\\n for z in xrange(min_z, max_z, 10):\\n global x_pos\\n global y_pos\\n global z_pos\\n x_pos = x_pos + [x]\\n y_pos = y_pos + [y]\\n z_pos = z_pos + [z]\\n contact_point, value = retractionPoint(bal_loc, np.matrix([[x], [y],\\n [z]]), direction, 1)\\n #print \\\"contact\\\", contact_point\\n if value > best_pos:\\n best_pos = value\\n kick_x = x\\n kick_y = y\\n kick_z = z\\n \\n contact = [contact_point[0,0], contact_point[1,0], contact_point[2,0]]\\n return contact, [kick_x, kick_y, kick_z]\",\n \"def genImgVfixedPos(filename=None,seeing=0,npix=None,zenith=0,filter='r', theta=0., corrector='corrector',x=None,y=None,z=None,suband=None):\\n datalist = []\\n hdrlist = []\\n xmm,ymm = np.meshgrid([-120,-80,-40,-20,0,20,40,80,120],[-120,-80,-40,-20,0,20,40,80,120])\\n xmm = xmm.flatten()\\n ymm = ymm.flatten()\\n Nstar = len(xmm)\\n for i in range(Nstar):\\n res = decamspot(xmm=xmm[i],ymm=ymm[i],seeing=seeing,npix=npix,zenith=zenith,filter=filter, theta=theta, corrector=corrector,x=x,y=y,z=z,suband=suband)\\n datalist.append(res[0])\\n hdrlist.append(res[1])\\n data = np.array(datalist)\\n if filename is not None:\\n hdu = pf.PrimaryHDU(data)\\n hdu.header.set('RAYPATT',raypattern)\\n hdu.header.set('NPIX',npix)\\n hdu.header.set('SCALE',scale)\\n hdu.header.set('FWHM',fwhm)\\n hdu.header.set('ZENITH',zenith)\\n hdu.header.set('FILTER',filter)\\n hdu.header.set('THETA',theta)\\n hdu.header.set('CORRT',corrector)\\n if x != None:\\n hdu.header.set('X',x)\\n if y != None:\\n hdu.header.set('Y',y)\\n if z != None:\\n hdu.header.set('Z',z)\\n if seeing != 0.:\\n hdu.header.set('s_fwhm',seeing[0])\\n hdu.header.set('e1',seeing[1])\\n hdu.header.set('e2',seeing[2])\\n if os.path.exists(filename):\\n os.system('rm '+filename)\\n hdu.writeto(filename)\\n else:\\n hdu.writeto(filename) \\n return data,hdrlist\",\n \"def aperture_phot(self,data,x,y,v):\\n r = np.sqrt((x-self.avg_map_fits['Values'][1])**2 + (y-self.avg_map_fits['Values'][3])**2)\\n \\n inner = (r < 8./60.) & np.isfinite(data) \\n outer = (r > 8.5/60.) & (r < 12./60.) & np.isfinite(data)\\n\\n annu = np.nanmedian(data[outer])\\n annu_rms = np.nanstd(data[outer])\\n flux = np.sum(data[inner]) - annu*np.sum(inner)\\n\\n c = 3e8\\n kb=1.38e-23\\n beam = (1./60.*np.pi/180.)**2\\n factor = 2*kb*(v*1e9/c)**2 * beam * 1e26\\n return flux*factor, annu_rms*np.sqrt(np.sum(inner))*factor\",\n \"def find_position(self, xv, yv):\\n # Convert position in spheric coord\\n phi = xv*self.FOV_img/360/self.img_res\\n theta = yv*self.FOV_img_Y/180/self.img_res_Y\\n phi2 = phi+(360-self.FOV_img)/2\\n theta2 = theta+(180-self.FOV_img_Y)/2\\n\\n u, v, w = spheric2cart(np.radians(theta2), np.radians(phi2)) # give cartesian coord of pixel\\n\\n # ignore errors due to /0 -> inf, -inf\\n # divide (w/v) and invalid arctan2()\\n with np.errstate(all='ignore'): # OPTIMIZE: see comment about pi = -pi and don't matter if -0 or 0 -> just replace by pi\\n beta = -np.arctan(w/v)\\n# beta2 = -np.arctan2(w, v)\\n\\n# v2 = np.dot(rotation_matrix(beta), [u, v, w]) # take 3*3 created matrix and aplly to vector\\n matrix = rotation_matrix(beta)\\n u2 = matrix[0, 0]*u\\n v2 = matrix[1, 1]*v+matrix[1, 2]*w\\n w2 = matrix[2, 1]*v+matrix[2, 2]*w\\n _, seen_angle = cart2spheric(u2, v2, w2) # return phi in equator \\\"projection\\\"\\n\\n seen_angle = np.degrees(seen_angle)\\n seen_angle = np.mod(seen_angle, 360) # define phi [0, 360]\\n\\n# seen_angle[seen_angle > 360] -= 360\\n deviated_angle = np.zeros(seen_angle.shape)\\n deviated_angle[seen_angle < 180] = self.interpolation(seen_angle[seen_angle < 180])\\n deviated_angle[seen_angle >= 180] = 360 - self.interpolation(360-seen_angle[seen_angle >= 180])\\n# np.flip(deviated_angle, 1) \\\" mais probleme overlap entre left et right\\n\\n theta = pi/2# *np.ones(deviated_angle.shape)\\n phi = np.radians(deviated_angle)\\n u3, v3, w3 = spheric2cart(theta, phi) #get cart coord of deviated pixel\\n\\n matrix = rotation_matrix(-beta)\\n u4 = matrix[0, 0]*u3\\n v4 = matrix[1, 1]*v3+matrix[1, 2]*w3\\n w4 = matrix[2, 1]*v3+matrix[2, 2]*w3\\n\\n theta, phi = cart2spheric(u4, v4, w4) #give spheric coord of deviated pixel\\n\\n theta, phi = np.degrees(theta), np.degrees(phi)\\n\\n phi -= (360-self.FOV_img)/2\\n theta -= (180-self.FOV_img_Y)/2\\n\\n with np.errstate(all='ignore'): # OPTIMIZE\\n phi = np.mod(phi, 360) # define phi [0, 360]\\n theta = np.mod(theta, 180) # define phi [0, 360]\\n\\n phi[phi == 360] = 0\\n xv2 = phi*360/self.FOV_img*self.img_res\\n yv2 = theta*180/self.FOV_img_Y*self.img_res_Y #give deviated angle pixel position\\n\\n xv2[np.isnan(xv2)] = -1\\n yv2[np.isnan(yv2)] = -1\\n\\n xv2 = np.array(xv2, dtype=int)\\n yv2 = np.array(yv2, dtype=int)\\n\\n return xv2, yv2\",\n \"def test_cspad_xy_at_z():\\n ## 'CxiDs1.0:Cspad.0)' or 'DscCsPad'\\n basedir = '/reg/g/psdm/detector/alignment/cspad/calib-cxi-camera1-2014-09-24/'\\n fname_geometry = basedir + '2016-06-03-geometry-cxi06216-r25-camera1-z175mm.txt'\\n fname_data = basedir + '2016-06-03-chun-cxi06216-0025-DscCsPad-max.txt'\\n\\n geometry = GeometryAccess(fname_geometry, pbits=0o377)\\n\\n # get pixel coordinate index arrays:\\n xyc = xc, yc = 1000, 1000\\n #rows, cols = geometry.get_pixel_coord_indexes(xy0_off_pix=xyc)\\n #rows, cols = geometry.get_pixel_coord_indexes(do_tilt=True)\\n #rows, cols = geometry.get_pixel_xy_inds_at_z(zplane=None, xy0_off_pix=xyc)\\n rows, cols = geometry.get_pixel_xy_inds_at_z(zplane=150000)\\n\\n root, ext = os.path.splitext(fname_data)\\n arr = np.load(fname_data) if ext == '.npy' else np.loadtxt(fname_data, dtype=np.float)\\n\\n #logger.info('arr.shape=', arr.shape\\n arr.shape= (32,185,388)\\n\\n #ave, rms = arr.mean(), arr.std()\\n #amp_range = (ave-rms, ave+3*rms)\\n amp_range = (0, 1000)\\n logger.info('amp_range:' + str(amp_range))\\n\\n logger.info('shapes rows: %s cols: %s weight: %s' % (str(rows.shape), str(cols.shape), str(arr.shape)))\\n img = img_from_pixel_arrays(rows,cols,W=arr)\\n\\n axim = gg.plotImageLarge(img,amp_range=amp_range)\\n gg.move(500,10)\\n gg.show()\",\n \"def get_sigma_map(start_x = 0,field_height=100,field_width=100,viewing_distance=12.0,screen_pixel_size=0.282,debug=False):\\n start_x_pixels = np.round(get_pixels_at_degrees(degrees=start_x,viewing_distance=viewing_distance,screen_pixel_size=screen_pixel_size))\\n optical_nodal_distance = 17.0 # mm from lens to fovea\\n viewing_distance_inches = viewing_distance\\n viewing_distance = viewing_distance * 25.4 # mm\\n center_y, center_x = 0,0\\n x_coords = (start_x_pixels + np.arange(-field_width/2.0,field_width/2,1))*screen_pixel_size\\n y_coords = np.arange(-field_height/2.0,field_height/2,1)*screen_pixel_size\\n x,y = np.meshgrid(x_coords,y_coords)\\n coords = np.vstack((y.ravel(),x.ravel())).T\\n\\n image_dist = cdist(np.matrix([center_y,center_x]),coords)\\n fovea_dist = (np.pi/180.0)*optical_nodal_distance*get_degrees_at_pixels(pixels=image_dist/screen_pixel_size,viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size)\\n midget_dendritic_field_diameter_micrometers = 8.64 * np.power(fovea_dist,1.04) # midget from Dacey and Peterson, 1994\\n midget_dendritic_field_diameter_millimeters = midget_dendritic_field_diameter_micrometers/1000.0\\n midget_projected_field_diameter_on_image = get_pixels_at_degrees(degrees=start_x+np.degrees(np.arctan((midget_dendritic_field_diameter_millimeters/2.0)/optical_nodal_distance)),viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size) - get_pixels_at_degrees(degrees=start_x-np.degrees(np.arctan((midget_dendritic_field_diameter_millimeters/2.0)/optical_nodal_distance)),viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size)\\n\\n midget_sigma_map = midget_projected_field_diameter_on_image / 6.0 # ensures 99.7% of dendrites are connected to field diameter\\n midget_sigma_map = midget_sigma_map.reshape((field_height,field_width))\\n\\n parasol_dendritic_field_diameter_micrometers = 70.2 * np.power(fovea_dist,0.65) # parasol from Dacey and Peterson, 1994\\n parasol_dendritic_field_diameter_millimeters = parasol_dendritic_field_diameter_micrometers/1000.0\\n parasol_projected_field_diameter_on_image = get_pixels_at_degrees(degrees=start_x+np.degrees(np.arctan((parasol_dendritic_field_diameter_millimeters/2.0)/optical_nodal_distance)),viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size) - get_pixels_at_degrees(degrees=start_x-np.degrees(np.arctan((parasol_dendritic_field_diameter_millimeters/2.0)/optical_nodal_distance)),viewing_distance=viewing_distance_inches,screen_pixel_size=screen_pixel_size)\\n parasol_sigma_map = parasol_projected_field_diameter_on_image / 6.0 # ensures 99.7% of dendrites are connected to field diameter\\n parasol_sigma_map = parasol_sigma_map.reshape((field_height,field_width))\\n\\n return midget_sigma_map,parasol_sigma_map\",\n \"def magnetic_field(self, xyz):\\n dxyz = self.vector_distance(xyz)\\n r = spatial.repeat_scalar(self.distance(xyz))\\n kr = self.wavenumber * r\\n ikr = 1j*kr\\n\\n front_term = (\\n self.current * self.length / (4 * np.pi * r**2) * (ikr + 1) *\\n np.exp(-ikr)\\n )\\n return -front_term * self.cross_orientation(dxyz) / r\",\n \"def B_outside_sphere(sphere_radius, dipole_pos, dipole_moment, detector_positions):\\n\\n\\n pos = np.array(dipole_pos, dtype=float)*1e-3\\n moment = np.array(dipole_moment, dtype=float)\\n detector = np.array(detector_positions, dtype=float)*1e-3\\n\\n assert np.all(np.linalg.norm(detector_positions, axis=1) >sphere_radius), \\\"All points must be outside the sphere\\\"\\n\\n assert np.all(np.linalg.norm(dipole_pos) <sphere_radius), \\\"Dipole must be outside sphere\\\"\\n\\n B = np.zeros(detector_positions.shape, dtype=float)\\n\\n for ii, r in enumerate(detector):\\n norm_r = np.linalg.norm(r)\\n\\n r_0 = pos\\n norm_r0 = np.linalg.norm(pos)\\n\\n a = r - r_0\\n norm_a = np.linalg.norm(a)\\n\\n F = norm_a * (norm_r * norm_a + norm_r**2 - r_0.dot(r))\\n\\n grad_F = (norm_r**(-1) * norm_a**2 + norm_a**(-1) * a.dot(r) + 2 * norm_a + 2 * norm_r) * r - \\\\\\n (norm_a + 2 * norm_r + norm_a**(-1) * a.dot(r)) * r_0\\n\\n B[ii, :] = (4 * np.pi * 1e-7) /\\\\\\n (4 * np.pi * F**2) * (F * np.cross(moment, r_0) - np.dot(np.cross(moment, r_0), r) * grad_F)\\n\\n return B\",\n \"def __call__(self, coords, params={}, basis=\\\"rpz\\\"):\\n return self.compute_magnetic_field(coords, params, basis)\",\n \"def param2pos( param, stickguy ):\\n\\n hip_pos = np.array([0.0, param[0]])\\n spine_vec = np.array([0.0, 1.0])\\n spine_vec = rotate(spine_vec, param[1])\\n neck_pos = hip_pos + spine_vec\\n basic_arm_vec = -0.6*spine_vec\\n arm_vec = rotate(basic_arm_vec, param[2])\\n left_elbow_pos = neck_pos + arm_vec\\n arm_vec = rotate(arm_vec, param[3])\\n left_hand_pos = left_elbow_pos + arm_vec\\n lad = np.array([neck_pos,left_elbow_pos,left_hand_pos])\\n stickguy.left_arm.set_data(lad[:,0],lad[:,1])\\n\\n arm_vec = rotate(basic_arm_vec, param[4])\\n right_elbow_pos = neck_pos + arm_vec\\n arm_vec = rotate(arm_vec, param[5])\\n right_hand_pos = right_elbow_pos + arm_vec\\n rad = np.array([neck_pos,right_elbow_pos,right_hand_pos])\\n stickguy.right_arm.set_data(rad[:,0],rad[:,1])\\n\\n neck_vec = 0.3*spine_vec\\n neck_vec = rotate( neck_vec, param[6])\\n head_pos = neck_pos + neck_vec\\n sd = np.array([hip_pos,neck_pos,head_pos])\\n stickguy.spine.set_data(sd[:,0],sd[:,1])\\n\\n basic_leg_vec = (0.0,-0.7)\\n leg_vec = rotate(basic_leg_vec, param[7])\\n left_knee_pos = hip_pos + leg_vec\\n leg_vec = rotate(leg_vec, param[8])\\n left_foot_pos = left_knee_pos + leg_vec\\n lld = np.array([hip_pos,left_knee_pos,left_foot_pos])\\n stickguy.left_leg.set_data(lld[:,0],lld[:,1])\\n\\n leg_vec = rotate(basic_leg_vec, param[9])\\n right_knee_pos = hip_pos + leg_vec\\n leg_vec = rotate(leg_vec, param[10])\\n right_foot_pos = right_knee_pos + leg_vec\\n rld = np.array([hip_pos,right_knee_pos,right_foot_pos])\\n stickguy.right_leg.set_data(rld[:,0],rld[:,1])\\n\\n return\",\n \"def getMagneticFieldMap(self):\\n return self.solenoid.B_interp(self.z_array)\",\n \"def Ez_area(position, angle, detect):\\n# a = range(round(-2*Ez_height),round(2*Ez_height))\\n# b = range(round(-2*Ez_height),round(2*Ez_height))\\n# a_valid = []\\n# b_valid= []\\n \\n # These are the grid points in a coordinate system based on the Ez's angle\\n if detect:\\n a_valid = [-11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6]\\n b_valid = [-6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3]\\n else:\\n a_valid = [-9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4]#[-19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -19, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -18, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -17, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -16, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -15, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -14, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -13, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -12, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -11, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -10, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -9, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -8, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -7, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -6, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9]\\n b_valid = [-4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -4, -3, -2, -1, 0, 1, 2, 3, 4, -3, -2, -1, 0, 1, 2, 3, -2, -1, 0, 1, 2]#[-9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, -4, -3, -2, -1, 0, 1, 2, 3, 4]\\n positions = []\\n# for i in a:\\n# for j in b:\\n# if (i > ((Ez_width/2)-Ez_height-detect_length) and abs(j) < (Ez_width/2+detect_length) and i < 0) or (i > 0 and np.sqrt(i**2 + j**2) < Ez_width/2+detect_length):\\n# a_valid.append(i)\\n# b_valid.append(j)\\n# print('AAAA', a_valid)\\n# print(' ')\\n# print('BBBB', b_valid)\\n# print(' ')\\n \\n # This is a coordinate transfromation to x,y\\n for i in range(len(a_valid)):\\n positions.append((int(round(a_valid[i]*np.cos(angle) + b_valid[i]*np.sin(angle) + position[0])), int(round(a_valid[i]*np.sin(angle) - b_valid[i]*np.cos(angle) + position[1]))))\\n return positions\",\n \"def calculate_beam_xy(self):\\n info = []\\n\\n # Import relevant info\\n pixel_size = self.info.pixel_size\\n for i in [j.final for j in self.final_objects]:\\n try:\\n info.append(\\n [\\n i,\\n i[\\\"beamX\\\"],\\n i[\\\"beamY\\\"],\\n i[\\\"wavelength\\\"],\\n i[\\\"distance\\\"],\\n (i[\\\"a\\\"], i[\\\"b\\\"], i[\\\"c\\\"], i[\\\"alpha\\\"], i[\\\"beta\\\"], i[\\\"gamma\\\"]),\\n ]\\n )\\n except IOError as e:\\n print(\\\"IOTA ANALYSIS ERROR: BEAMXY failed! \\\", e)\\n pass\\n\\n # Calculate beam center coordinates and distances\\n beamX = [i[1] for i in info]\\n beamY = [j[2] for j in info]\\n beam_dist = [\\n math.hypot(i[1] - np.median(beamX), i[2] - np.median(beamY)) for i in info\\n ]\\n beam_dist_std = np.std(beam_dist)\\n img_list = [\\n [i[0], i[1], i[2], i[3], i[4], i[5], j]\\n for i, j in list(zip(info, beam_dist))\\n ]\\n\\n # Separate out outliers\\n outliers = [i for i in img_list if i[3] > 2 * beam_dist_std]\\n clean = [i for i in img_list if i[3] <= 2 * beam_dist_std]\\n cbeamX = [i[1] for i in clean]\\n cbeamY = [j[2] for j in clean]\\n obeamX = [i[1] for i in outliers]\\n obeamY = [j[2] for j in outliers]\\n\\n # Calculate median wavelength, detector distance and unit cell params from\\n # non-outliers only\\n wavelengths = [i[3] for i in clean]\\n distances = [i[4] for i in clean]\\n cells = [i[5] for i in clean]\\n\\n wavelength = np.median(wavelengths)\\n det_distance = np.median(distances)\\n a = np.median([i[0] for i in cells])\\n b = np.median([i[1] for i in cells])\\n c = np.median([i[2] for i in cells])\\n\\n # Calculate predicted L +/- 1 misindexing distance for each cell edge\\n aD = det_distance * math.tan(2 * math.asin(wavelength / (2 * a)))\\n bD = det_distance * math.tan(2 * math.asin(wavelength / (2 * b)))\\n cD = det_distance * math.tan(2 * math.asin(wavelength / (2 * c)))\\n\\n return (\\n beamX,\\n beamY,\\n cbeamX,\\n cbeamY,\\n obeamX,\\n obeamY,\\n beam_dist,\\n [i[4] for i in info],\\n aD,\\n bD,\\n cD,\\n pixel_size,\\n )\",\n \"def stempot(self,xmax,ymax,nx,ny,atms,pixelshift,scalefactor):\\n #zed=2 for rutherford scattering of the nucleus, less for screening\\n zed = 1.7\\n\\n ix = numpy.arange(1.0,nx)\\n iy = numpy.arange(1.0,ny)\\n dx = xmax/nx\\n dy = ymax/ny\\n rx = numpy.arange(0,xmax-dx,dx)\\n ry = numpy.arange(0,ymax-dy,dy)\\n\\n Zatom = atms.get_atomic_numbers()\\n #translate atoms such that the center of mass is in the center of the computational cell\\n com = atms.get_center_of_mass()\\n #com = [ 44.40963074 , 44.65497562 , 44.90406073] #for AuNP\\n #com = numpy.array(com)\\n #print 'com',com -0.149836425, 0.29967285, 0\\n #com += [0.41205016875, 0.6742639125, 0] #for rotated line profile \\n #com += [-0.149836425, 0.29967285, 0] #for AuNP\\n #com += pixelshift\\n #print 'com+pixelshift',com\\n cop = xmax/2.0\\n trans = [cop-i for i in com]\\n atms.translate(trans)\\n positions=atms.get_positions()\\n ax=[]\\n ay=[]\\n az=[]\\n for o,t,h in positions:\\n ax.append(o)\\n ay.append(t)\\n az.append(h)\\n ax = numpy.array(ax)\\n ay = numpy.array(ay)\\n az = numpy.array(az)\\n amax = len(Zatom)\\n\\n #find boundaries of slice\\n axmin = min(ax)\\n axmax = max(ax)\\n aymin = min(ay)\\n aymax = max(ay)\\n\\n V= numpy.zeros((nx,ny))\\n\\n #map x and y coords of the atoms to the nearest grid points\\n #A fraction of the atom must be assigned to the closest gridpoints\\n #to avoid sum and difference frequencies appearing in the image\\n #grid point to the left of the atom\\n ix = numpy.array([math.floor(axi/dx) for axi in ax])\\n #apply periodic boundary conditions\\n iax = numpy.array([math.fmod(iaxi,nx) for iaxi in ix])\\n ibx = numpy.array([math.fmod(iaxi+1,nx) for iaxi in ix])\\n #fraction of atom at iax\\n fax = numpy.array([1-math.fmod((axi/dx),1 ) for axi in ax])\\n #grid point above the atom\\n iy = numpy.array([math.floor(ayi/dy) for ayi in ay])\\n #apply periodic boundary conditions\\n iay = numpy.array([math.fmod(iayi,ny) for iayi in iy])\\n iby = numpy.array([math.fmod(iayi+1,ny) for iayi in iy])\\n #fraction of atom at iay \\n fay = numpy.array([1-math.fmod((ayi/dy),1 ) for ayi in ay])\\n #Add each atom to the potential grid\\n V1 = numpy.array([fax[i] * fay[i] * (Zatom[i]**zed) for i in range(len(fax))])\\n V2 = numpy.array([(1-fax[i]) * fay[i] * (Zatom[i]**zed) for i in range(len(fax))])\\n V3 = numpy.array([fax[i] * (1-fay[i]) * (Zatom[i]**zed) for i in range(len(fax))])\\n V4 = numpy.array([(1-fax[i]) * (1-fay[i]) * (Zatom[i]**zed) for i in range(len(fax))])\\n #V1 = numpy.array([fax[i] * fay[i] * scalefactor for i in range(len(fax))])\\n #V2 = numpy.array([(1-fax[i]) * fay[i] * scalefactor for i in range(len(fax))])\\n #V3 = numpy.array([fax[i] * (1-fay[i]) * scalefactor for i in range(len(fax))])\\n #V4 = numpy.array([(1-fax[i]) * (1-fay[i]) * scalefactor for i in range(len(fax))])\\n\\n for j in range(amax):\\n V[iax[j],iay[j]] += V1[j]\\n V[ibx[j],iay[j]] += V2[j]\\n V[iax[j],iby[j]] += V3[j]\\n V[ibx[j],iby[j]] += V4[j]\\n rev_trans = [-1.0*i for i in trans]\\n atms.translate(rev_trans)\\n return V\",\n \"def box_collision_info(self):\\r\\n position = np.zeros((self.Npart,3)) # antall part, dim, iterasjoner\\r\\n position[:,:] = np.random.uniform(0,1e-6, size = (self.Npart,3))\\r\\n velocity = np.zeros((self.Npart,3))\\r\\n velocity[:,:] = np.random.normal(0,self.sigma,size = (self.Npart,3))\\r\\n\\r\\n part_collided = 0\\r\\n part_escaped = 0\\r\\n momentum = 0\\r\\n\\r\\n print 'engine started'\\r\\n for i in xrange(1,self.n):\\r\\n #collision\\r\\n position += velocity*dt\\r\\n l_hole = position[:,0:2] > self.L/4\\r\\n h_hole = position[:,0:2] < (3*self.L)/4\\r\\n pos_xy = np.logical_and(l_hole, h_hole)\\r\\n pos_xy = np.logical_and(pos_xy[:,0], pos_xy[:,1])\\r\\n pos_z = position[:,2] < 0\\r\\n esc_part = np.logical_and(pos_z, pos_xy)\\r\\n\\r\\n #velocity[esc_part] = velocity[esc_part]\\r\\n part_escaped += np.sum(esc_part)\\r\\n\\r\\n for j in xrange(0,3):\\r\\n impact_wall_pos = np.logical_and(position[:,j] > 0,\\r\\n position[:,j] < self.L)\\r\\n velocity[np.logical_not(impact_wall_pos),j] = -velocity[\\r\\n np.logical_not(impact_wall_pos),j]\\r\\n\\r\\n\\r\\n if j == 0:\\r\\n part_collided += np.sum(np.logical_not(impact_wall_pos),j)\\r\\n momentum += np.sum(2*self.m*abs(velocity[np.logical_not(\\r\\n impact_wall_pos),j]))\\r\\n\\r\\n\\r\\n\\r\\n position[position < 0] = 0\\r\\n position[position >self.L] = self.L\\r\\n\\r\\n particle_collided = part_collided/2\\r\\n return position, velocity,part_escaped, impact_wall_pos, particle_collided, momentum\",\n \"def clashTest(self, px, py, pz, rad):\\n radSq = rad**2\\n # adjust for map not set at origin\\n px -= self.unif[0]\\n py -= self.unif[1]\\n pz -= self.unif[2]\\n ht = self.height/255\\n halfw = self.width/2.0\\n halfd = self.depth/2.0\\n dx = self.width/self.ix\\n dz = self.depth/self.iy\\n\\n # work out x and z ranges to check, x0 etc correspond with vertex indices in grid\\n x0 = int(math.floor((halfw + px - rad)/dx + 0.5)) - 1\\n if x0 < 0: x0 = 0\\n x1 = int(math.floor((halfw + px + rad)/dx + 0.5)) + 1\\n if x1 > self.ix-1: x1 = self.ix-1\\n z0 = int(math.floor((halfd + pz - rad)/dz + 0.5)) - 1\\n if z0 < 0: z0 = 0\\n z1 = int(math.floor((halfd + pz + rad)/dz + 0.5)) + 1\\n if z1 > self.iy-1: z1 = self.iy-1\\n\\n # go through grid around px, pz\\n minDist, minLoc = 1000000, (0, 0)\\n for i in xrange(x0+1, x1):\\n for j in xrange(z0+1, z1):\\n # use the locations stored in the one dimensional vertices matrix\\n #generated in __init__. 3 values for each location\\n p = j*self.ix + i # pointer to the start of xyz for i,j in the vertices array\\n p1 = j*self.ix + i - 1 # pointer to the start of xyz for i-1,j\\n p2 = (j-1)*self.ix + i # pointer to the start of xyz for i, j-1\\n vertp = self.buf[0].vertices[p]\\n normp = self.buf[0].normals[p]\\n # work out distance squared from this vertex to the point\\n distSq = (px - vertp[0])**2 + (py - vertp[1])**2 + (pz - vertp[2])**2\\n if distSq < minDist: # this vertex is nearest so keep a record\\n minDist = distSq\\n minLoc = (i, j)\\n #now find the distance between the point and the plane perpendicular\\n #to the normal at this vertex\\n pDist = dot([px - vertp[0], py - vertp[1], pz - vertp[2]],\\n [-normp[0], -normp[1], -normp[2]])\\n #and the position where the normal from point crosses the plane\\n xIsect = px - normp[0]*pDist\\n zIsect = pz - normp[2]*pDist\\n\\n #if the intersection point is in this rectangle then the x,z values\\n #will lie between edges\\n if xIsect > self.buf[0].vertices[p1][0] and \\\\\\n xIsect < self.buf[0].vertices[p][0] and \\\\\\n zIsect > self.buf[0].vertices[p2][2] and \\\\\\n zIsect < self.buf[0].vertices[p][2]:\\n pDistSq = pDist**2\\n # finally if the perpendicular distance is less than the nearest so far\\n #keep a record\\n if pDistSq < minDist:\\n minDist = pDistSq\\n minLoc = (i,j)\\n\\n gLevel = self.calcHeight(px, pz) #check it hasn't tunnelled through by going fast\\n if gLevel > (py-rad):\\n minDist = py - gLevel\\n minLoc = (int((x0+x1)/2), int((z0+z1)/2))\\n\\n if minDist <= radSq: #i.e. near enough to clash so return normal\\n p = minLoc[1]*self.ix + minLoc[0]\\n normp = self.buf[0].normals[p]\\n if minDist < 0:\\n jump = rad - minDist\\n else:\\n jump = 0\\n return(True, normp[0], normp[1], normp[2], jump)\\n else:\\n return (False, 0, 0, 0, 0)\",\n \"def clashTest(self, px, py, pz, rad):\\r\\n radSq = rad**2\\r\\n # adjust for map not set at origin\\r\\n px -= self.unif[0]\\r\\n py -= self.unif[1]\\r\\n pz -= self.unif[2]\\r\\n ht = self.height/255\\r\\n halfw = self.width/2.0\\r\\n halfd = self.depth/2.0\\r\\n dx = self.width/self.ix\\r\\n dz = self.depth/self.iy\\r\\n\\r\\n # work out x and z ranges to check, x0 etc correspond with vertex indices in grid\\r\\n x0 = int(math.floor((halfw + px - rad)/dx + 0.5)) - 1\\r\\n if x0 < 0: x0 = 0\\r\\n x1 = int(math.floor((halfw + px + rad)/dx + 0.5)) + 1\\r\\n if x1 > self.ix-1: x1 = self.ix-1\\r\\n z0 = int(math.floor((halfd + pz - rad)/dz + 0.5)) - 1\\r\\n if z0 < 0: z0 = 0\\r\\n z1 = int(math.floor((halfd + pz + rad)/dz + 0.5)) + 1\\r\\n if z1 > self.iy-1: z1 = self.iy-1\\r\\n\\r\\n # go through grid around px, pz\\r\\n minDist, minLoc = 1000000, (0, 0)\\r\\n for i in xrange(x0+1, x1):\\r\\n for j in xrange(z0+1, z1):\\r\\n # use the locations stored in the one dimensional vertices matrix\\r\\n #generated in __init__. 3 values for each location\\r\\n p = j*self.ix + i # pointer to the start of xyz for i,j in the vertices array\\r\\n p1 = j*self.ix + i - 1 # pointer to the start of xyz for i-1,j\\r\\n p2 = (j-1)*self.ix + i # pointer to the start of xyz for i, j-1\\r\\n vertp = self.buf[0].vertices[p]\\r\\n normp = self.buf[0].normals[p]\\r\\n # work out distance squared from this vertex to the point\\r\\n distSq = (px - vertp[0])**2 + (py - vertp[1])**2 + (pz - vertp[2])**2\\r\\n if distSq < minDist: # this vertex is nearest so keep a record\\r\\n minDist = distSq\\r\\n minLoc = (i, j)\\r\\n #now find the distance between the point and the plane perpendicular\\r\\n #to the normal at this vertex\\r\\n pDist = dot([px - vertp[0], py - vertp[1], pz - vertp[2]],\\r\\n [-normp[0], -normp[1], -normp[2]])\\r\\n #and the position where the normal from point crosses the plane\\r\\n xIsect = px - normp[0]*pDist\\r\\n zIsect = pz - normp[2]*pDist\\r\\n\\r\\n #if the intersection point is in this rectangle then the x,z values\\r\\n #will lie between edges\\r\\n if xIsect > self.buf[0].vertices[p1][0] and \\\\\\r\\n xIsect < self.buf[0].vertices[p][0] and \\\\\\r\\n zIsect > self.buf[0].vertices[p2][2] and \\\\\\r\\n zIsect < self.buf[0].vertices[p][2]:\\r\\n pDistSq = pDist**2\\r\\n # finally if the perpendicular distance is less than the nearest so far\\r\\n #keep a record\\r\\n if pDistSq < minDist:\\r\\n minDist = pDistSq\\r\\n minLoc = (i,j)\\r\\n\\r\\n gLevel = self.calcHeight(px, pz) #check it hasn't tunnelled through by going fast\\r\\n if gLevel > (py-rad):\\r\\n minDist = py - gLevel\\r\\n minLoc = (int((x0+x1)/2), int((z0+z1)/2))\\r\\n\\r\\n if minDist <= radSq: #i.e. near enough to clash so return normal\\r\\n p = minLoc[1]*self.ix + minLoc[0]\\r\\n normp = self.buf[0].normals[p]\\r\\n if minDist < 0:\\r\\n jump = rad - minDist\\r\\n else:\\r\\n jump = 0\\r\\n return(True, normp[0], normp[1], normp[2], jump)\\r\\n else:\\r\\n return (False, 0, 0, 0, 0)\",\n \"def compute_magnetic_field(self, coords, params=None, basis=\\\"rpz\\\"):\\n assert basis.lower() in [\\\"rpz\\\", \\\"xyz\\\"]\\n if isinstance(coords, Grid):\\n coords = coords.nodes\\n coords = jnp.atleast_2d(coords)\\n if basis == \\\"xyz\\\":\\n coords = xyz2rpz(coords)\\n bp = self._B0 * self._R0 / coords[:, 0]\\n brz = jnp.zeros_like(bp)\\n B = jnp.array([brz, bp, brz]).T\\n if basis == \\\"xyz\\\":\\n B = rpz2xyz_vec(B, phi=coords[:, 1])\\n\\n return B\",\n \"def magnetization(h):\\n if h.has_eh: raise\\n if h.has_spin: \\n mx = extract.mx(h.intra)\\n my = extract.my(h.intra)\\n mz = extract.mz(h.intra)\\n else: raise\\n np.savetxt(\\\"MAGNETIZATION_X.OUT\\\",np.matrix([h.geometry.x,h.geometry.y,mx]).T)\\n np.savetxt(\\\"MAGNETIZATION_Y.OUT\\\",np.matrix([h.geometry.x,h.geometry.y,my]).T)\\n np.savetxt(\\\"MAGNETIZATION_Z.OUT\\\",np.matrix([h.geometry.x,h.geometry.y,mz]).T)\",\n \"def compute_magnetic_field(self, coords, params=None, basis=\\\"rpz\\\"):\\n assert basis.lower() in [\\\"rpz\\\", \\\"xyz\\\"]\\n if isinstance(coords, Grid):\\n coords = coords.nodes\\n coords = jnp.atleast_2d(coords)\\n if basis == \\\"xyz\\\":\\n coords = xyz2rpz(coords)\\n\\n R, phi, Z = coords.T\\n r = jnp.sqrt((R - self._R0) ** 2 + Z**2)\\n theta = jnp.arctan2(Z, R - self._R0)\\n br = -r * jnp.sin(theta)\\n bp = jnp.zeros_like(br)\\n bz = r * jnp.cos(theta)\\n bmag = self._B0 * self._iota / self._R0\\n B = bmag * jnp.array([br, bp, bz]).T\\n if basis == \\\"xyz\\\":\\n B = rpz2xyz_vec(B, phi=coords[:, 1])\\n\\n return B\",\n \"def compute_magnetic_field(self, coords, params=None, basis=\\\"rpz\\\"):\\n assert basis.lower() in [\\\"rpz\\\", \\\"xyz\\\"]\\n if isinstance(coords, Grid):\\n coords = coords.nodes\\n coords = jnp.atleast_2d(coords)\\n if basis == \\\"xyz\\\":\\n coords = xyz2rpz(coords)\\n Rq, phiq, Zq = coords.T\\n if self._axisym:\\n BRq = interp2d(\\n Rq,\\n Zq,\\n self._R,\\n self._Z,\\n self._BR[:, 0, :],\\n self._method,\\n (0, 0),\\n self._extrap,\\n (None, None),\\n **self._derivs[\\\"BR\\\"],\\n )\\n Bphiq = interp2d(\\n Rq,\\n Zq,\\n self._R,\\n self._Z,\\n self._Bphi[:, 0, :],\\n self._method,\\n (0, 0),\\n self._extrap,\\n (None, None),\\n **self._derivs[\\\"Bphi\\\"],\\n )\\n BZq = interp2d(\\n Rq,\\n Zq,\\n self._R,\\n self._Z,\\n self._BZ[:, 0, :],\\n self._method,\\n (0, 0),\\n self._extrap,\\n (None, None),\\n **self._derivs[\\\"BZ\\\"],\\n )\\n\\n else:\\n BRq = interp3d(\\n Rq,\\n phiq,\\n Zq,\\n self._R,\\n self._phi,\\n self._Z,\\n self._BR,\\n self._method,\\n (0, 0, 0),\\n self._extrap,\\n (None, self._period, None),\\n **self._derivs[\\\"BR\\\"],\\n )\\n Bphiq = interp3d(\\n Rq,\\n phiq,\\n Zq,\\n self._R,\\n self._phi,\\n self._Z,\\n self._Bphi,\\n self._method,\\n (0, 0, 0),\\n self._extrap,\\n (None, self._period, None),\\n **self._derivs[\\\"Bphi\\\"],\\n )\\n BZq = interp3d(\\n Rq,\\n phiq,\\n Zq,\\n self._R,\\n self._phi,\\n self._Z,\\n self._BZ,\\n self._method,\\n (0, 0, 0),\\n self._extrap,\\n (None, self._period, None),\\n **self._derivs[\\\"BZ\\\"],\\n )\\n B = jnp.array([BRq, Bphiq, BZq]).T\\n if basis == \\\"xyz\\\":\\n B = rpz2xyz_vec(B, phi=coords[:, 1])\\n return B\",\n \"def compute_magnetic_field(self, coords, params=None, basis=\\\"rpz\\\"):\\n assert basis.lower() in [\\\"rpz\\\", \\\"xyz\\\"]\\n if isinstance(coords, Grid):\\n coords = coords.nodes\\n coords = jnp.atleast_2d(coords)\\n if basis == \\\"xyz\\\":\\n coords = xyz2rpz(coords)\\n Rq, phiq, Zq = coords.T\\n\\n if (params is None) or (len(params) == 0):\\n params = self._params\\n r, p, z = coords.T\\n funR = lambda x: self._potential(x, p, z, **params)\\n funP = lambda x: self._potential(r, x, z, **params)\\n funZ = lambda x: self._potential(r, p, x, **params)\\n br = Derivative.compute_jvp(funR, 0, (jnp.ones_like(r),), r)\\n bp = Derivative.compute_jvp(funP, 0, (jnp.ones_like(p),), p)\\n bz = Derivative.compute_jvp(funZ, 0, (jnp.ones_like(z),), z)\\n B = jnp.array([br, bp / r, bz]).T\\n if basis == \\\"xyz\\\":\\n B = rpz2xyz_vec(B, phi=coords[:, 1])\\n return B\",\n \"def magnetic_field(self, xyz):\\n dxyz = self.vector_distance(xyz)\\n r = spatial.repeat_scalar(self.distance(xyz))\\n kr = self.wavenumber*r\\n ikr = 1j*kr\\n\\n front_term = self.moment / (4. * np.pi * r**3) * np.exp(-ikr)\\n symmetric_term = (\\n spatial.repeat_scalar(self.dot_orientation(dxyz)) * dxyz *\\n (-kr**2 + 3*ikr + 3) / r**2\\n )\\n oriented_term = (\\n (kr**2 - ikr - 1) *\\n np.kron(self.orientation, np.ones((dxyz.shape[0], 1)))\\n )\\n\\n return front_term * (symmetric_term + oriented_term)\",\n \"def get_data(eh, file_list):\\n x_pos = []\\n y_pos = []\\n x_vel = []\\n y_vel = []\\n z_vel = []\\n unique_x = []\\n unique_y = []\\n\\n # reading data\\n for file in file_list:\\n with open(file, 'r') as f:\\n f.readline() # Ignores first line\\n for line in f:\\n line = line.strip()\\n column = line.split()\\n if len(column) == 4:\\n if file == file_list[0]:\\n # Only takes position data from first file as the same in each file\\n x_pos.append(float(column[0]))\\n y_pos.append(float(column[1]))\\n\\n x_vel.append(float(column[2]))\\n y_vel.append(float(column[3]))\\n z_vel.append(0.0)\\n\\n if float(column[0]) not in unique_x:\\n unique_x.append(float(column[0]))\\n if float(column[1]) not in unique_y:\\n unique_y.append(float(column[1]))\\n else:\\n x_vel.append(float(column[2]))\\n y_vel.append(float(column[3]))\\n z_vel.append(0.0)\\n else:\\n print \\\"Error: TXT file is not correct!\\\"\\n\\n ux = len(unique_x)\\n uy = len(unique_y)\\n\\n\\n # xmid and ymid are used to get xz- and yz-planes. The median value is used. If the number of\\n # unique xs and ys is even, then the median value will be one that does not correspond to a\\n # measurement. When this is the case, the first value is ignored so that the number of uniques is\\n # odd, resulting in a median value that corresponds to a measurement.\\n if ux % 2 == 0:\\n xmid = np.median(unique_x[1:])\\n else:\\n xmid = np.median(unique_x)\\n\\n if uy % 2 == 0:\\n ymid = np.median(unique_y[1:])\\n else:\\n ymid = np.median(unique_y)\\n\\n if eh == exp_h_list[-1]:\\n print \\\"All data read.\\\"\\n\\n\\n # checks list lengths to ensure matching and then averages the velocities for all files\\n # and then returns an array with position and average velocities\\n if len(x_pos) == len(y_pos):\\n pos_count = len(x_pos)\\n if len(x_vel) == len(y_vel) and len(x_vel) == len(z_vel):\\n vel_count = len(x_vel)\\n nof = vel_count / pos_count # equals number of files for each height\\n ax_vel, ay_vel, az_vel = avg_data_each_h(nof, pos_count, x_vel, y_vel, z_vel)\\n\\n if make_sg:\\n subgrid_array = sub_grid(ux, x_pos, y_pos, eh, ax_vel, ay_vel, az_vel)\\n return subgrid_array\\n else:\\n z_pos = [eh] * len(x_pos)\\n return xmid, ymid, zip(x_pos, y_pos, z_pos, ax_vel, ay_vel, az_vel)\\n else:\\n print \\\"Error: different number of velocities!\\\"\\n else:\\n print \\\"Error: not all x-positions have a corresponding y-position!\\\"\",\n \"def compute_magnetic_field(self, coords, params=None, basis=\\\"rpz\\\"):\\n assert basis.lower() in [\\\"rpz\\\", \\\"xyz\\\"]\\n if isinstance(coords, Grid):\\n coords = coords.nodes\\n coords = jnp.atleast_2d(coords)\\n if basis == \\\"xyz\\\":\\n coords = xyz2rpz(coords)\\n bz = self._B0 * jnp.ones_like(coords[:, 2])\\n brp = jnp.zeros_like(bz)\\n B = jnp.array([brp, brp, bz]).T\\n if basis == \\\"xyz\\\":\\n B = rpz2xyz_vec(B, phi=coords[:, 1])\\n\\n return B\",\n \"def rotationDetermination(self):\\n \\n for index, row in enumerate(self.magdata):\\n if index > 11 and index < (len(self.magdata) - 12):\\n br1 = [row[0] for row in self.magdata[(index-12):(index-2)]]\\n bt1 = [row[1] for row in self.magdata[(index-12):(index-2)]]\\n bn1 = [row[2] for row in self.magdata[(index-12):(index-2)]]\\n b1 = np.matrix((np.mean(br1), np.mean(bt1), np.mean(bn1)))\\n\\n br2 = [row[0] for row in self.magdata[(index+2):(index+12)]]\\n bt2 = [row[1] for row in self.magdata[(index+2):(index+12)]]\\n bn2 = [row[2] for row in self.magdata[(index+2):(index+12)]]\\n b2 = np.matrix((np.mean(br2), np.mean(bt2), np.mean(bn2)))\\n\\n theta = np.arccos(np.dot(b1,b2.T)/(np.linalg.norm(b1)*np.linalg.norm(b2)))*180/np.pi\\n\\n self.detections.rotations.append(theta[0,0])\\n self.detections.rotationTimeTags.append(self.timestamps[index])\\n \\n\\n## self.b1 = b1\\n## self.b2 = b2\\n self.detections.rotationBoundary=[]\\n if len(self.detections.rotations) != 0:\\n \\n for index, theta in enumerate(self.detections.rotations):\\n if index > 0:\\n if theta > 30 and self.detections.rotations[index-1] < 30:\\n self.detections.rotationBoundary.append(self.detections.rotationTimeTags[index])\\n if index < len(self.detections.rotations)-1:\\n if theta > 30 and self.detections.rotations[index+1] < 30:\\n self.detections.rotationBoundary.append(self.detections.rotationTimeTags[index])\",\n \"def get_things1(kp_3d, kp_2d, des, comp_list, H, map_3d, map_2d, map_des, map_cam, map_view, my_max):\\n # Initializing the arrays\\n points_3d = []\\n points_2d = []\\n camera_ind = []\\n points_ind = []\\n cam_params = []\\n\\n dst_3d = kp_3d\\n dst_2d = kp_2d\\n src_3d = map_3d\\n src_2d = map_2d\\n src_cam = map_cam\\n low_bound = []\\n up_bound = []\\n my_min = 0\\n\\n # Updating the Camera parameters in map and setting the bounds for the update \\n for i in range(my_min,my_max+1):\\n cam_param = [map_view[i,0], map_view[i,1], map_view[i,2], map_view[i,3], map_view[i,4], map_view[i,5], f,0,0]\\n cam_params.append(cam_param)\\n\\n low_bound.append(-np.pi)\\n low_bound.append(-np.pi)\\n low_bound.append(-np.pi)\\n low_bound.append(-20)\\n low_bound.append(-np.inf)\\n low_bound.append(-20)\\n low_bound.append(f-1)\\n low_bound.append(-1)\\n low_bound.append(-1)\\n up_bound.append(np.pi)\\n up_bound.append(np.pi)\\n up_bound.append(np.pi)\\n up_bound.append(20)\\n up_bound.append(np.inf)\\n up_bound.append(20)\\n up_bound.append(f)\\n up_bound.append(0)\\n up_bound.append(0)\\n \\n # Updating the Camera parameters for frame and setting the bounds for the update\\n r = (R.from_matrix((H[0:3, 0:3]))).as_rotvec()\\n t = H[:,3]\\n cam_param = [r[0], r[1], r[2], t[0], t[1], t[2], f, 0, 0]\\n cam_params.append(cam_param)\\n \\n low_bound.append(-np.pi)\\n low_bound.append(-np.pi)\\n low_bound.append(-np.pi)\\n low_bound.append(-20)\\n low_bound.append(-np.inf)\\n low_bound.append(-20)\\n low_bound.append(f-1)\\n low_bound.append(-1)\\n low_bound.append(-1)\\n up_bound.append(np.pi)\\n up_bound.append(np.pi)\\n up_bound.append(np.pi)\\n up_bound.append(20)\\n up_bound.append(np.inf)\\n up_bound.append(20)\\n up_bound.append(f)\\n up_bound.append(0)\\n up_bound.append(0)\\n\\n new_cam = len(cam_params)-1\\n cam_params = np.array(cam_params).reshape(-1,9)\\n count = 0\\n \\n # listing variables to iterate \\n l1 = []\\n l2 = []\\n count = 0\\n \\n for m in comp_list:\\n count+=1\\n l1.append(m.queryIdx)\\n l2.append(m.trainIdx)\\n\\n l1 = np.array(l1).reshape(1,-1)\\n l2 = np.array(l2).reshape(1,-1)\\n l = np.vstack((l1,l2))\\n l_fin = l[:,l[1, :].argsort()]\\n j = 0\\n count = len(points_3d)\\n prev = -1\\n final_l1 = []\\n final_l2 = []\\n final_des = []\\n\\n # Iterating through the list made and making sure no duplicates\\n while(j<(len(l_fin[0]))):\\n i1 = l_fin[0,j]\\n i2 = l_fin[1,j]\\n if(i2!=prev):\\n # Map points insertion\\n \\n check = 0\\n for ii in range(len(src_2d[i1])):\\n m_2d = src_2d[i1][ii]\\n check = 1\\n ind = int(src_cam[i1][ii])\\n points_2d.append([int((m_2d[0]%(2*cx))-cx), int((m_2d[1]%(2*cy))-cy),0])\\n\\n points_ind.append(count)\\n camera_ind.append(ind)\\n final_l1.append(i1)\\n final_l2.append(0)\\n \\n # Taking Mean Desciptor if needed un comment 2 lines below\\n # x = ((map_des[i1]*len(src_2d[i1]))+des[i2])/(len(src_2d[i1])+1)\\n # map_des[i1] = x\\n \\n if(check==1):\\n # Frame points insersion\\n points_2d.append([int((dst_2d[i2,0])-cx), int((dst_2d[i2,1])-cy), 0])\\n points_ind.append(count)\\n camera_ind.append(new_cam)\\n final_l1.append(i2)\\n final_l2.append(1)\\n wld_pt = src_3d[i1]\\n points_3d.append([wld_pt[0], wld_pt[1], wld_pt[2]])\\n prev = i2\\n count = len(points_3d)\\n low_bound.append(-20)\\n low_bound.append(-np.inf)\\n low_bound.append(-20)\\n up_bound.append(20)\\n up_bound.append(np.inf)\\n up_bound.append(20)\\n src_2d[i1].append([int((dst_2d[i2,0])), int((dst_2d[i2,1]))])\\n j+=1\\n \\n # Final Output\\n cam_params = np.array(cam_params).reshape(-1,9)\\n points_3d = np.array(points_3d)\\n points_2d = np.array(points_2d)\\n camera_ind = np.array(camera_ind).reshape(len(camera_ind))\\n points_ind = np.array(points_ind).reshape(len(points_ind))\\n final_l1 = np.array(final_l1)\\n final_l2 = np.array(final_l2)\\n return cam_params, points_3d, points_2d, camera_ind, points_ind, final_l1, final_l2, low_bound, up_bound, map_des, src_2d\",\n \"def get_motion(frame1k, frame2k, frame_count):\\n frame1 = frame1k.copy()\\n frame2 = frame2k.copy()\\n\\n global limb_coords, init_coords, num_blocks\\n cv2.imwrite(\\\"thisImageAnalyse.png\\\", frame2)\\n block_size = 3\\n block_rad = int(block_size/2)\\n\\n def get_SSD():\\n \\\"\\\"\\\" applies SSD formula to search area\\n :return SSD value\\\"\\\"\\\"\\n dist = 0\\n # traversal of pixels in potential Bi+1 block\\n # compare corresponding pixel positions with source block in f1 and neighbour block in f2\\n y1 = center_y1 - block_rad # start pos.\\n for y2 in range(center_y2 - block_rad, (center_y2 - block_rad + block_size)):\\n x1 = center_x1 - block_rad # start pos\\n for x2 in range(center_x2 - block_rad, (center_x2 - block_rad + block_size)):\\n try:\\n # displacement formula for RGB channels of each pixel in block\\n dist = dist + (frame1[y1][x1][0] - frame2[y2][x2][0])**2 + (frame1[y1][x1][1] - frame2[y2][x2][1])**2 + (frame1[y1][x1][2] - frame2[y2][x2][2])**2\\n except RuntimeWarning:\\n pass\\n x1 += 1\\n y1 += 1\\n return math.sqrt(dist)\\n\\n # for each body part\\n b = 0\\n while b < 5:\\n avg_x = 0.0\\n avg_y = 0.0\\n new_x = 0.0\\n new_y = 0.0\\n a = 0\\n # for each block on body part (9 total)\\n while a < num_blocks:\\n found = False\\n search_rad = 5\\n while found is False:\\n center_y1 = int(init_coords[b][a][0])\\n center_x1 = int(init_coords[b][a][1])\\n min_SSD = 999999\\n # for pythagoras to ensure closest block gets picked when equality occurs of SSD value\\n min_d = 999999\\n # this finds the center of the block to compare\\n for factor_y in range(-search_rad, search_rad + 1):\\n center_y2 = center_y1 + block_size*factor_y\\n y_dist = center_y1 - abs(center_y2)\\n for factor_x in range(-search_rad, search_rad + 1):\\n center_x2 = center_x1 + block_size*factor_x\\n x_dist = center_x1 - abs(center_x2)\\n # pythagoras\\n d = math.sqrt((y_dist**2 + x_dist**2))\\n if d < min_d:\\n min_d = d\\n\\n SSD = get_SSD()\\n if frame2[center_y2][center_x2][1] != 0 and frame2[center_y2][center_x2][2] != 0:\\n found = True\\n if SSD < min_SSD:\\n min_SSD = SSD\\n new_y = center_y2\\n new_x = center_x2\\n elif SSD == min_SSD and d < min_d:\\n new_y = center_y2\\n new_x = center_x2\\n if found is False:\\n # if no block is found repeat the search, increasing the search size by 1\\n search_rad += 1\\n # draw extracted vectors\\n cv2.arrowedLine(frame1k, (int(center_x1), int(center_y1)), (int(new_x), int(new_y)), (150, 200, 30), 1, 4, 0, 0.3)\\n avg_x += new_x\\n avg_y += new_y\\n init_coords[b][a][0] = new_y\\n init_coords[b][a][1] = new_x\\n a += 1\\n cv2.imwrite('monkeyFrames/contrast_enhanced%d.png' % frame_count, frame1k)\\n limb_coords[b][frame_count][0] = int(avg_y/num_blocks)\\n limb_coords[b][frame_count][1] = int(avg_x/num_blocks)\\n b += 1\",\n \"def update_position(self, event):\\n\\n # Create a copy of the most recent stored twist data to perform calculations\\n with self.lock:\\n velocity_data = copy.deepcopy(self.twist)\\n\\n # Time elapsed since last update position call\\n if hasattr(event, 'last_real'):\\n if event.last_real is None:\\n time = rospy.Duration(0.05)\\n else:\\n time = event.current_real - event.last_real\\n \\n time = time.to_sec()\\n\\n # Calculate angle turned in the given time using omega = theta/time\\n angle = velocity_data.angular.z*time\\n\\n # Calculate distance travelled in the given time using linear velocity = arc distance/time\\n distance = velocity_data.linear.x*time\\n\\n # Calculate yaw of the robot\\n self.vehicle_yaw += angle\\n\\n # Calculate vehicle x, y, z position coordinates\\n # TODO recalculate the position based on traveling in a circular arc.\\n self.pose.position.x += (distance)*cos(self.vehicle_yaw)\\n self.pose.position.y += (distance)*sin(self.vehicle_yaw)\\n\\n # Calculate z position using linear interpolation and create cloud array\\n \\n # 1. Create ranges to be used in interpolation function\\n terrain_points_x = np.arange(0, self.gaussian_array.shape[1]*self.resolution, self.resolution)\\n terrain_points_y = np.arange(0, self.gaussian_array.shape[0]*self.resolution, self.resolution)\\n\\n # 2. Create array of points to be converted to point cloud for vizualization\\n terrain_mesh_x, terrain_mesh_y = np.meshgrid(terrain_points_x, terrain_points_y)\\n terrain_x = terrain_mesh_x.ravel()\\n terrain_y = terrain_mesh_y.ravel()\\n terrain_z = self.gaussian_array.ravel()\\n terrain_grid_points = np.stack((terrain_x, terrain_y, terrain_z), axis=1)\\n\\n # 3. Create interpolation function based on the ranges and gaussian data\\n interp_func = RectBivariateSpline(terrain_points_y, terrain_points_x, self.gaussian_array)\\n\\n # 4. Find z value for x and y coordinate of vehicle using interpolation function\\n # TODO compute z height based on footprint\\n self.pose.position.z = interp_func(self.pose.position.y, self.pose.position.x)\\n\\n # Convert Euler Angles to Quarternion\\n V_rotation = tf.transformations.quaternion_from_euler(0.0, 0.0, self.vehicle_yaw)\\n\\n # Broadcast vehicle frame which is a child of the world frame\\n br = tf.TransformBroadcaster()\\n br.sendTransform((self.pose.position.x, self.pose.position.y, self.pose.position.z), \\n V_rotation, rospy.Time.now(),\\\"vehicle_frame\\\", \\\"map\\\")\\n\\n # Construct the homogenous transformation matrix for map to vehicle frame\\n V_translation = [self.pose.position.x, self.pose.position.y, self.pose.position.z]\\n map_T_V = tf.transformations.quaternion_matrix(V_rotation) \\n map_T_V[:3,3] = np.array(V_translation)\\n\\n # Create footprint of vehicle\\n V_footprint_range_x = np.linspace((-self.vehicle_length/2), (self.vehicle_length/2), 30)\\n V_footprint_range_y = np.linspace((-self.vehicle_width/2), (self.vehicle_width/2), 15)\\n V_footprint_mesh_x, V_footprint_mesh_y = np.meshgrid(V_footprint_range_x, V_footprint_range_y)\\n V_footprint_x = V_footprint_mesh_x.ravel()\\n V_footprint_y = V_footprint_mesh_y.ravel()\\n\\n # For every point in the vehicle footprint, calculate the position wrt to the vehicle's frame\\n # and its interpolated z value. Add this point to a list of points for visualization.\\n # TODO Flatten into a single matrix multiply to remove for loop\\n V_viz_points = []\\n for i in range(V_footprint_x.shape[0]):\\n p = Point()\\n V_footprint_point = np.array([[V_footprint_x[i]],[V_footprint_y[i]], [0.0], [1.0]])\\n V_footprint_point = np.matmul(map_T_V, V_footprint_point)\\n V_footprint_point[2, 0] = interp_func(V_footprint_point[1, 0], V_footprint_point[0, 0])\\n p.x = V_footprint_point[0, 0]\\n p.y = V_footprint_point[1, 0]\\n p.z = V_footprint_point[2, 0]\\n V_viz_points.append(p)\\n\\n #####################################################################################\\n # Create a copy of the most recent stored JointState data to perform calculations\\n with self.joint_lock:\\n joint_data = copy.deepcopy(self.joint)\\n\\n # If the data is empty on first run, fill with 0.0\\n if not joint_data.velocity:\\n joint_data.velocity = [0.0,0.0]\\n \\n # Calculate angle based on velocity data and time\\n angle = joint_data.velocity[0]*time\\n angle2 = joint_data.velocity[1]*time\\n\\n self.joint1_pitch += angle\\n self.joint2_pitch += angle2\\n\\n # Transformations from vehicle frame to Joint1 and Joint2\\n \\n # Static rotation about z-axis \\n static_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 3.14159)\\n translation = [0.0, 0.0, 0.0]\\n V_T_SRz = tf.transformations.quaternion_matrix(static_rot)\\n V_T_SRz[:3,3] = np.array(translation)\\n\\n # Dynamic rotation about the y-axis of Joint 1\\n rot_SRz_T_J1 = [[cos(self.joint1_pitch), 0.0, sin(self.joint1_pitch)],\\n [0.0, 1.0, 0.0],\\n [-sin(self.joint1_pitch), 0.0, cos(self.joint1_pitch)]]\\n\\n trans_SRz_T_J1 = [0.0, 0.0, 0.0, 1.0]\\n\\n SRz_T_J1 = np.zeros((4,4))\\n SRz_T_J1[:3,:3] = rot_SRz_T_J1\\n SRz_T_J1[:4,3] = trans_SRz_T_J1\\n\\n # Translation based on length of Joint 1 arm \\n no_rot = tf.transformations.quaternion_from_euler(0.0, 0.0, 0.0)\\n translation = [self.joint1_length, 0.0, 0.0]\\n J1_T_STx = tf.transformations.quaternion_matrix(no_rot)\\n J1_T_STx[:3,3] = np.array(translation)\\n\\n # Dynamic rotation about y-axis of Joint 2\\n dynamic_rot2 = tf.transformations.quaternion_from_euler(0.0, self.joint2_pitch, 0.0)\\n translation = [0.0, 0.0, 0.0]\\n STx_T_J2 = tf.transformations.quaternion_matrix(dynamic_rot2)\\n STx_T_J2[:3,3] = np.array(translation)\\n\\n # matrix multiplication to form the homogenous matrices\\n V_T_J1 = np.matmul(V_T_SRz, SRz_T_J1)\\n V_T_STx = np.matmul(V_T_J1, J1_T_STx)\\n V_T_J2 = np.matmul(V_T_STx, STx_T_J2)\\n\\n frame_J1 = tf_conversions.fromMatrix(V_T_J1)\\n frame_J2 = tf_conversions.fromMatrix(V_T_J2)\\n\\n # The ripper tip is a point in the J2's frame, this is based on the length of the ripper\\n ripper_tip_point_J2 = [self.ripper_length, 0.0, 0.0, 1.0]\\n map_T_J2 = np.matmul(map_T_V, V_T_J2)\\n ripper_tip_pt_map = np.matmul(map_T_J2, ripper_tip_point_J2)\\n ripper_tip_point_viz = Point()\\n ripper_tip_point_viz.x = ripper_tip_pt_map[0]\\n ripper_tip_point_viz.y = ripper_tip_pt_map[1]\\n ripper_tip_point_viz.z = ripper_tip_pt_map[2]\\n V_viz_points.append(ripper_tip_point_viz)\\n\\n # use the ripper's position as an index value to access the gaussian array\\n ripper_tip_cell_index_x = int(ripper_tip_pt_map[1]/self.resolution)\\n ripper_tip_cell_index_y = int(ripper_tip_pt_map[0]/self.resolution)\\n\\n # Create a range of index values surrounding index_x and y\\n nearby_index_cells_range_x = np.arange((ripper_tip_cell_index_x-1),(ripper_tip_cell_index_x+2), 1)\\n nearby_index_cells_range_y = np.arange((ripper_tip_cell_index_y-1),(ripper_tip_cell_index_y+2), 1)\\n nearby_index_cells_mesh_x, nearby_index_cells_mesh_y = np.meshgrid(nearby_index_cells_range_x,nearby_index_cells_range_y)\\n nearby_index_cells_x = nearby_index_cells_mesh_x.ravel()\\n nearby_index_cells_y = nearby_index_cells_mesh_y.ravel()\\n\\n # First check if the index is within the gaussian array, if it is, then check if the tip of\\n # the ripper is beneath the soil, if it is, then remove the soil above the tip and disperse\\n # it to the surrounding cells, provided those cells are also within the gaussian array\\n # TODO Remove use of for loops and excess if statements\\n\\n if (0 <= ripper_tip_cell_index_x <= (self.gaussian_array.shape[0]-1)) and (0 <= ripper_tip_cell_index_y <= (self.gaussian_array.shape[1]-1)):\\n if (self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] > ripper_tip_pt_map[2]):\\n diff = self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] - ripper_tip_pt_map[2]\\n for i in range(nearby_index_cells_x.shape[0]):\\n if (0 <= nearby_index_cells_x[i] <= (self.gaussian_array.shape[0]-1)) and (0 <= nearby_index_cells_y[i] <= (self.gaussian_array.shape[1]-1)):\\n self.gaussian_array[nearby_index_cells_x[i]][nearby_index_cells_y[i]] += diff/8\\n self.gaussian_array[ripper_tip_cell_index_x][ripper_tip_cell_index_y] = ripper_tip_pt_map[2]\\n \\n\\n # Publish all messages\\n self.publish_messages(V_translation, V_rotation, terrain_grid_points, V_viz_points, frame_J1, frame_J2)\",\n \"def cozmoBehavior(robot: cozmo.robot.Robot):\\r\\n \\r\\n global grid, stopevent\\r\\n\\r\\n foundGoal = False\\r\\n foudnCenter = False\\r\\n setPath = False\\r\\n seen_cubes = []\\r\\n goToCenter = False\\r\\n start_ori = grid.getStart()\\r\\n\\r\\n while not stopevent.is_set():\\r\\n if foundGoal == False:\\r\\n if robot.pose.rotation.angle_z.degrees <= 90:\\r\\n \\r\\n cube = None\\r\\n\\r\\n try:\\r\\n cube = robot.world.wait_for_observed_light_cube(timeout=2)\\r\\n\\r\\n print(\\\"Found cube: %s\\\" % cube)\\r\\n \\r\\n if cube not in seen_cubes:\\r\\n seen_cubes.append(cube)\\r\\n\\r\\n pos = cube.pose.position\\r\\n x, y, z = pos.x, pos.y, pos.z\\r\\n print()\\r\\n obs1 = int(x/grid.scale + start_ori[0] + 0.5), int(y/grid.scale + start_ori[1] + 0.5)\\r\\n add_obs = []\\r\\n for i in range(-1, 2, 1):\\r\\n for j in range(-1, 2, 1):\\r\\n ob = obs1[0] + i, obs1[1] + j\\r\\n add_obs.append(ob)\\r\\n grid.addObstacles(add_obs);\\r\\n\\r\\n if cube.object_id == robot.world.light_cubes[cozmo.objects.LightCube1Id].object_id:\\r\\n\\r\\n foundGoal = True\\r\\n \\r\\n cube_angle = cube.pose.rotation.angle_z.degrees\\r\\n a, b = 0, 0\\r\\n if cube_angle > -22.5 and cube_angle < 22.5:\\r\\n a, b = -1, 0\\r\\n if cube_angle >= 22.5 and cube_angle < 67.5:\\r\\n a, b = -1, -1\\r\\n if cube_angle >= 67.5 and cube_angle < 112.5:\\r\\n a, b = 0, -1\\r\\n if cube_angle >= 112.5 and cube_angle < 157.5:\\r\\n a, b = 1, -1\\r\\n if cube_angle >= 157.5 or cube_angle <= -157.5:\\r\\n a, b = 1, 0\\r\\n if cube_angle > -67.5 and cube_angle <= -22.5:\\r\\n a, b = -1, 1\\r\\n if cube_angle > -112.5 and cube_angle <= -67.5:\\r\\n a, b = 0, 1\\r\\n if cube_angle > -157.5 and cube_angle <= -112.5:\\r\\n a, b = 1, 1\\r\\n\\r\\n goal = obs1[0] + a * 2, obs1[1] + b * 2\\r\\n grid.clearGoals()\\r\\n grid.addGoal(goal)\\r\\n\\r\\n except asyncio.TimeoutError:\\r\\n print(\\\"Didn't find a cube\\\")\\r\\n\\r\\n robot.turn_in_place(degrees(30)).wait_for_completed()\\r\\n else:\\r\\n robot.turn_in_place(degrees(-90)).wait_for_completed()\\r\\n if not foundGoal:\\r\\n goal = int(grid.width/2), int(grid.height/2)\\r\\n grid.clearGoals()\\r\\n grid.addGoal(goal)\\r\\n foundGoal = True\\r\\n foundCenter = True\\r\\n else:\\r\\n \\r\\n robot_pose = robot.pose\\r\\n # print(robot_pose)\\r\\n rx, ry = robot_pose.position.x, robot_pose.position.y\\r\\n cx = int(rx/grid.scale + start_ori[0] + 0.5)\\r\\n cy = int(ry/grid.scale + start_ori[1] + 0.5)\\r\\n # update start\\r\\n grid.clearStart()\\r\\n grid.setStart((cx, cy))\\r\\n\\r\\n astar(grid, heuristic)\\r\\n path = grid.getPath()\\r\\n print(path)\\r\\n prev = path[0]\\r\\n i = 1\\r\\n while i < len(path):\\r\\n p = path[i]\\r\\n diff = p[0] - prev[0], p[1] - prev[1]\\r\\n\\r\\n try:\\r\\n cube = robot.world.wait_for_observed_light_cube(timeout=1)\\r\\n\\r\\n if cube:\\r\\n if cube not in seen_cubes:\\r\\n # update map\\r\\n seen_cubes.append(cube)\\r\\n pos = cube.pose.position\\r\\n x, y, z = pos.x, pos.y, pos.z\\r\\n print()\\r\\n obs1 = int(x/grid.scale + start_ori[0] + 0.5), int(y/grid.scale + start_ori[1] + 0.5)\\r\\n add_obs = []\\r\\n for i in range(-1, 2, 1):\\r\\n for j in range(-1, 2, 1):\\r\\n ob = obs1[0] + i, obs1[1] + j\\r\\n add_obs.append(ob)\\r\\n grid.addObstacles(add_obs)\\r\\n\\r\\n if cube.object_id == robot.world.light_cubes[cozmo.objects.LightCube1Id].object_id:\\r\\n foundGoal = True\\r\\n foundCenter = False\\r\\n cube_angle = cube.pose.rotation.angle_z.degrees\\r\\n # print(\\\"cube angle is: \\\", cube_angle)\\r\\n a, b = 0, 0\\r\\n if cube_angle > -22.5 and cube_angle < 22.5:\\r\\n a, b = -1, 0\\r\\n if cube_angle >= 22.5 and cube_angle < 67.5:\\r\\n a, b = -1, -1\\r\\n if cube_angle >= 67.5 and cube_angle < 112.5:\\r\\n a, b = 0, -1\\r\\n if cube_angle >= 112.5 and cube_angle < 157.5:\\r\\n a, b = 1, -1\\r\\n if cube_angle >= 157.5 or cube_angle <= -157.5:\\r\\n a, b = 1, 0\\r\\n if cube_angle > -67.5 and cube_angle <= -22.5:\\r\\n a, b = -1, 1\\r\\n if cube_angle > -112.5 and cube_angle <= -67.5:\\r\\n a, b = 0, 1\\r\\n if cube_angle > -157.5 and cube_angle <= -112.5:\\r\\n a, b = 1, 1\\r\\n\\r\\n goal = obs1[0] + a * 2, obs1[1] + b * 2\\r\\n # print(goal)\\r\\n grid.clearGoals()\\r\\n grid.addGoal(goal)\\r\\n # recalculate path\\r\\n grid.clearStart()\\r\\n grid.setStart(p)\\r\\n grid.clearPath()\\r\\n grid.clearVisited()\\r\\n astar(grid, heuristic)\\r\\n path = grid.getPath()\\r\\n print(\\\"new path is: \\\", path)\\r\\n i = 0\\r\\n # update the path\\r\\n except:\\r\\n print(\\\"Ball not in vision\\\")\\r\\n\\r\\n\\r\\n\\r\\n # Needs to verify\\r\\n curr_angle = robot.pose.rotation.angle_z\\r\\n angle = getAngle(diff)\\r\\n angle_to_turn = angle - curr_angle.degrees\\r\\n robot.turn_in_place(degrees(angle_to_turn)).wait_for_completed()\\r\\n\\r\\n d = math.sqrt(math.pow(diff[0], 2) + math.pow(diff[1], 2))\\r\\n robot.drive_straight(distance_mm(d*grid.scale), speed_mmps(40)).wait_for_completed()\\r\\n\\r\\n # Everytime we move, check to see if there's an obstacle in our vision\\r\\n\\r\\n prev = p\\r\\n i += 1\\r\\n\\r\\n \\r\\n if foundCenter == True: #not in the goal yet\\r\\n foundGoal = False\\r\\n foundCenter = False\\r\\n else:\\r\\n curr_angle = robot.pose.rotation.angle_z\\r\\n angle = cube_angle\\r\\n angle_to_turn = angle - curr_angle.degrees\\r\\n robot.turn_in_place(degrees(angle_to_turn)).wait_for_completed()\\r\\n break # Your code here\\r\",\n \"def detector(centre_x, centre_y, height_z, radius, distance):\\r\\n z = np.linspace(0, height_z, 50)\\r\\n z = [i+distance for i in z]\\r\\n \\r\\n theta = np.linspace(0, 2*np.pi, 50)\\r\\n theta_grid, z_grid=np.meshgrid(theta, z)\\r\\n \\r\\n x_grid = radius*np.cos(theta_grid) + centre_x\\r\\n y_grid = radius*np.sin(theta_grid) + centre_y\\r\\n return x_grid, y_grid, z_grid\",\n \"def galaxy_positions():\\n hdulist1 = pf.open(source+'/kids_data/KiDS_DR3.1_G9_ugri_shear.fits')\\n '''\\n hdulist2 = pf.open('../kids_data/KiDS_DR3.1_G12_ugri_shear.fits')\\n hdulist3 = pf.open('../kids_data/KiDS_DR3.1_G15_ugri_shear.fits')\\n hdulist4 = pf.open('../kids_data/KiDS_DR3.1_G23_ugri_shear.fits')\\n hdulist5 = pf.open('../kids_data/KiDS_DR3.1_GS_ugri_shear.fits')\\n '''\\n ra = hdulist1[1].data['RAJ2000'][:sample]\\n dec = hdulist1[1].data['DECJ2000'][:sample]\\n global maxra\\n maxra = max(ra)\\n global minra\\n minra = min(ra)\\n global maxdec\\n maxdec = max(dec)\\n global mindec\\n mindec = min(dec)\\n global bsize\\n bsize = abs(max(maxra, maxdec) - min(mindec, minra))\\n coords = np.column_stack([ra, dec])\\n global SIZE\\n SIZE = len(coords)\\n print(maxra, maxdec, minra, mindec, SIZE)\\n ctree = cKDTree(coords)\\n return ctree\",\n \"def update_mag(self, mags):\\n self.log.mag(mags)\\n q = self.quaternion()\\n roll, pitch, heading = self.es\\n\\n mag_inertial = (q * quaternion.Quaternion.from_vec(np.array(mags)) * q.inv()).as_ndarray()[1:]\\n mag_inertial[2] = 0\\n mag_inertial /= sqrt(mag_inertial[0]**2 + mag_inertial[1]**2)\\n mag_body = (q.inv() * quaternion.Quaternion.from_vec(mag_inertial) * q).as_ndarray()[1:]\\n\\n h = (q.inv() * quaternion.Quaternion.from_vec(np.array([1.0, 0, 0])) * q).as_ndarray()[1:]\\n y = np.vstack(mag_body) - np.vstack(h)\\n \\n H = np.zeros((3, 9))\\n ch2 = np.cos(heading/2)\\n cr2 = np.cos(roll/2)\\n sh2 = np.sin(heading/2)\\n sr2 = np.sin(roll/2)\\n H[0, 0] = 0\\n H[0, 1] = 0\\n H[0, 2] = -2.0*ch2*cr2**2*sh2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) - 2.0*ch2*sh2*sr2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2)\\n H[1, 0] = 4.0*ch2*cr2*sh2*sr2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2)\\n H[1, 1] = 2.0*ch2**2*cr2*sr2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) - 2.0*cr2*sh2**2*sr2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2)\\n H[1, 2] = -1.0*ch2**2*cr2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) + 1.0*ch2**2*sr2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) + 1.0*cr2**2*sh2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2) - 1.0*sh2**2*sr2**2/(1.0*ch2**2*cr2**2 + 1.0*ch2**2*sr2**2 + 1.0*cr2**2*sh2**2 + 1.0*sh2**2*sr2**2)\\n\\n S = H.dot(self.P).dot(H.T) + self.Rmag\\n K = self.P.dot(H.T).dot(np.linalg.inv(S))\\n x = self.state_vec() + K.dot(y)\\n\\n self.P = (np.eye(9) - K.dot(H)).dot(self.P)\\n self.set_state_vec(x)\",\n \"def FL_2_mav_sensor(self, data):\\n\\n (data['velocities/phidot-rad_sec_bf'],\\n data['velocities/thetadot-rad_sec_bf'],\\n data['velocities/psidot-rad_sec_bf']) = self.convert_body_frame(\\n data['attitude/phi-rad'],\\n data['attitude/theta-rad'],\\n data['velocities/phidot-rad_sec'],\\n data['velocities/thetadot-rad_sec'],\\n data['velocities/psidot-rad_sec']\\n )\\n\\n #Data treatment\\n messagedata = [\\n int(data['simulation/sim-time-sec']*self._sec2usec), #time_usec boot time usec int\\n data['accelerations/udot-ft_sec2'], #xacc m/s**2 float\\n data['accelerations/vdot-ft_sec2'], #yacc m/s**2 float\\n data['accelerations/wdot-ft_sec2'], #zacc m/s**2 float\\n data['velocities/phidot-rad_sec'], #xgyro rad/s float\\n data['velocities/thetadot-rad_sec'], #ygyro rad/s float\\n data['velocities/psidot-rad_sec'], #zgyro rad/s float\\n data['sensors/magnetometer/X/output'], #xmag Gauss float\\n data['sensors/magnetometer/Y/output'], #ymag Gauss float\\n data['sensors/magnetometer/Z/output'], #zmag Gauss float\\n data['atmosphere/P-psf']*0.478802589, #abs_pr mbar float\\n 0.0, #dif_pr mbar float\\n data['atmosphere/pressure-altitude'], #pr_alt meter float\\n 15.0, #temp C float\\n int(8186) #fields_updated (ALL)\\n ]\\n\\n return messagedata\",\n \"def magnetisation(field):\\n norm_field = df.Field(field.mesh, dim=1, value=(field.norm.array != 0))\\n volume = df.integral(norm_field * df.dV, direction='xyz')\\n return df.integral(field * df.dV / volume, direction='xyz')\",\n \"def magnetometer(self):\\n self._mag[X] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_X_H_M) << 8 | \\n self.i2c_bus.read_byte_data(self.addr, OUT_X_L_M), 16)\\n self._mag[Y] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_Y_H_M) << 8 | \\n self.i2c_bus.read_byte_data(self.addr, OUT_Y_L_M), 16)\\n self._mag[Z] = twos_comp(self.i2c_bus.read_byte_data(self.addr, OUT_Z_H_M) << 8 | \\n self.i2c_bus.read_byte_data(self.addr, OUT_Z_L_M), 16)\\n\\n return vector(self._mag)\",\n \"def read(filename, num_magnets):\\n hxy = []\\n with open(filename, encoding='latin1', errors='ignore') as f:\\n for s in readSections(f):\\n pos = float(s[0].split()[-1])\\n num = np.array([[float(x) for x in l.split()] for l in s[5:] if l])\\n hxy.append({'pos': pos, 'e': num[:, :2], 'hxy': num[:, 2:4],\\n 'bxy': num[:, 4:6], 'mxy':num[:, 6:]})\\n K = num_magnets\\n points = [point(i, np.random.randint(0,K), xy)\\n for i, xy in enumerate(hxy[0]['e'])]\\n new_means, new_points = fit(points)\\n # move values to magnets:\\n magnets = [{'e': [p.coord for p in new_points if p.k == k],\\n 'pos': [], 'hxy': [], 'bxy': [], 'mxy': []}\\n for k in range(K)]\\n hkeys = ['hxy', 'bxy', 'mxy']\\n for i, h in enumerate(hxy): # all positions\\n for mag in magnets:\\n mag['pos'].append(h['pos'])\\n m = [{k: [] for k in hkeys}\\n for kk in range(K)]\\n for p in new_points: # all elements\\n for k in hkeys:\\n m[p.k][k].append(h[k][p.k])\\n for mk, magk in zip(m, magnets):\\n for k in hkeys:\\n magk[k].append(mk[k])\\n for mag in magnets:\\n for k in ['e'] + hkeys:\\n mag[k] = np.array(mag[k])\\n mag['havg'] = []\\n mag['hmax'] = []\\n for hpos in mag['hxy']:\\n h = np.abs(np.linalg.norm(hpos, axis=1))\\n mag['havg'].append(np.mean(h))\\n mag['hmax'].append(np.max(h))\\n\\n # Note dimension of hkeys is (positions x elements x 2)\\n\\n return magnets\",\n \"def tf(xp, yp, zp, spheres, inc, dec, pmag=None):\\n if xp.shape != yp.shape != zp.shape:\\n raise ValueError(\\\"Input arrays xp, yp, and zp must have same shape!\\\")\\n tf = numpy.zeros_like(xp)\\n # Calculate the 3 components of the unit vector in the direction of the\\n # regional field\\n fx, fy, fz = utils.dircos(inc, dec)\\n if pmag is not None:\\n if isinstance(pmag, float) or isinstance(pmag, int):\\n pintensity = pmag\\n pmx, pmy, pmz = fx, fy, fz\\n else:\\n pintensity = numpy.linalg.norm(pmag)\\n pmx, pmy, pmz = numpy.array(pmag) / pintensity\\n for sphere in spheres:\\n if sphere is None or ('magnetization' not in sphere.props\\n and pmag is None):\\n continue\\n radius = sphere.radius\\n # Get the intensity and unit vector from the magnetization\\n if pmag is None:\\n mag = sphere.props['magnetization']\\n if isinstance(mag, float) or isinstance(mag, int):\\n intensity = mag\\n mx, my, mz = fx, fy, fz\\n else:\\n intensity = numpy.linalg.norm(mag)\\n mx, my, mz = numpy.array(mag) / intensity\\n else:\\n intensity = pintensity\\n mx, my, mz = pmx, pmy, pmz\\n # First thing to do is make the computation point P the origin of the\\n # coordinate system\\n x = sphere.x - xp\\n y = sphere.y - yp\\n z = sphere.z - zp\\n # Calculate the 3 components of B\\n dotprod = mx * x + my * y + mz * z\\n r_sqr = x ** 2 + y ** 2 + z ** 2\\n r5 = r_sqr ** (2.5)\\n moment = intensity * (4. * numpy.pi * (radius ** 3) / 3.)\\n bx = moment * (3 * dotprod * x - r_sqr * mx) / r5\\n by = moment * (3 * dotprod * y - r_sqr * my) / r5\\n bz = moment * (3 * dotprod * z - r_sqr * mz) / r5\\n tf += (fx * bx + fy * by + fz * bz)\\n tf *= CM * T2NT\\n return tf\",\n \"def ion2_position(self,x,y,z):\\n axes_vector = np.array([self.a,self.b,self.c])\\n self.ion2 = x*self.a + y*self.b + z*self.c\\n self.position['1B'] = np.dot(self.position_map[1],axes_vector) + self.ion2\\n self.position['2B'] = np.dot(self.position_map[2],axes_vector) + self.ion2\\n self.position['3B'] = np.dot(self.position_map[3],axes_vector) + self.ion2\\n self.position['4B'] = np.dot(self.position_map[4],axes_vector) + self.ion2\\n self.position['5B'] = np.dot(self.position_map[5],axes_vector) + self.ion2\\n self.position['6B'] = np.dot(self.position_map[6],axes_vector) + self.ion2\\n self.position['7B'] = np.dot(self.position_map[7],axes_vector) + self.ion2\\n self.position['8B'] = np.dot(self.position_map[8],axes_vector) + self.ion2\",\n \"def magnetic_reynolds(uu, param, grid, aa=list(), bb=list(), jj=list(),\\n nghost=3, lmix=True):\\n if len(bb) ==0 and len(aa) ==0 and len(jj) ==0:\\n print('magnetic_reynolds WARNING: no aa, bb nor jj provided\\\\n'+\\n 'aa or bb must be provided or aa for only hyper resistivity') \\n #resistive force\\n lres, lhyper3 = False, False\\n for iresi in param.iresistivity:\\n iresi = str.strip(iresi,'\\\\n')\\n if 'hyper' not in iresi and len(iresi) > 0:\\n lres = True\\n if 'hyper3' in iresi:\\n lhyper3 = True\\n fresi = np.zeros_like(uu)\\n if lres:\\n if lhyper3:\\n lhyper3 = lhyper3==lmix\\n if len(jj) == 0:\\n if len(aa) == 0:\\n print('magnetic_reynolds WARNING: calculating jj without aa\\\\n',\\n 'provide aa or jj directly for accurate boundary values')\\n jj = curl(bb,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \\n coordinate_system=param.coord_system)\\n else:\\n jj = curl2(aa,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \\n coordinate_system=param.coord_system)\\n for j in range(0,3):\\n jj[j, :nghost,:,:] = jj[j,-2*nghost:-nghost,:,:]\\n jj[j,-nghost:,:,:] = jj[j, nghost: 2*nghost,:,:]\\n jj[j,:, :nghost,:] = jj[j,:,-2*nghost:-nghost,:]\\n jj[j,:,-nghost:,:] = jj[j,:, nghost: 2*nghost,:]\\n jj[j,:,:, :nghost] = jj[j,:,:,-2*nghost:-nghost]\\n jj[j,:,:,-nghost:] = jj[j,:,:, nghost: 2*nghost]\\n fresi = fresi + param.eta*param.mu0*jj\\n for iresi in param.iresistivity:\\n iresi = str.strip(iresi,'\\\\n')\\n if 'eta-const' not in iresi and 'hyper' not in iresi\\\\\\n and len(iresi) > 0:\\n print('magnetic_reynolds WARNING: '+iresi+' not implemented\\\\n'+\\n 'terms may be missing from the standard resistive forces')\\n if lhyper3:\\n if len(aa) == 0:\\n print('magnetic_reynolds WARNING: no aa provided\\\\n'+\\n 'aa must be provided for hyper resistivity')\\n return 1\\n else:\\n del6a = np.zeros_like(aa)\\n for j in range(0,3):\\n del6a[j] = del6(aa[j],grid.dx,grid.dy,grid.dz)\\n del6a[j, :nghost,:,:] = del6a[j,-2*nghost:-nghost,:,:]\\n del6a[j,-nghost:,:,:] = del6a[j, nghost: 2*nghost,:,:]\\n del6a[j,:, :nghost,:] = del6a[j,:,-2*nghost:-nghost,:]\\n del6a[j,:,-nghost:,:] = del6a[j,:, nghost: 2*nghost,:]\\n del6a[j,:,:, :nghost] = del6a[j,:,:,-2*nghost:-nghost]\\n del6a[j,:,:,-nghost:] = del6a[j,:,:, nghost: 2*nghost]\\n #del6 for non-cartesian tba\\n #del6a[j] = del6(aa[j],grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y,\\n # coordinate_system=param.coord_system)\\n #effective at l > 5 grid.dx? \\n fresi = fresi + param.eta_hyper3*del6a\\n del(del6a)\\n fresi2 = np.sqrt(dot2(fresi))\\n del(fresi)\\n #advective force\\n if len(bb) == 0:\\n if len(aa) == 0:\\n print('magnetic_reynolds WARNING: calculating uu x bb without bb\\\\n',\\n 'provide aa or bb directly to proceed')\\n return 1\\n else:\\n bb = curl(aa,grid.dx,grid.dy,grid.dz,x=grid.x,y=grid.y, \\n coordinate_system=param.coord_system)\\n for j in range(0,3):\\n bb[j, :nghost,:,:] = bb[j,-2*nghost:-nghost,:,:]\\n bb[j,-nghost:,:,:] = bb[j, nghost: 2*nghost,:,:]\\n bb[j,:, :nghost,:] = bb[j,:,-2*nghost:-nghost,:]\\n bb[j,:,-nghost:,:] = bb[j,:, nghost: 2*nghost,:]\\n bb[j,:,:, :nghost] = bb[j,:,:,-2*nghost:-nghost]\\n bb[j,:,:,-nghost:] = bb[j,:,:, nghost: 2*nghost]\\n advec = cross(uu,bb)\\n advec2 = np.sqrt(dot2(advec))\\n del(advec)\\n #avoid division by zero\\n if fresi2.max() > 0:\\n fresi2[np.where(fresi2==0)] = fresi2[np.where(fresi2>0)].min()\\n Rm = advec2/fresi2\\n #set minimum floor to exclude zero-valued Rm \\n if Rm.max() > 0:\\n Rm[np.where(Rm==0)] = Rm[np.where(Rm>0)].min()\\n else:\\n print('Rm undefined')\\n else:\\n Rm = advec2\\n print('Rm undefined')\\n return Rm\",\n \"def CreateLandmask(Fieldset, test = False):\\n \\n \\n \\\"\\\"\\\"\\n This first set of lines creates a numpy array with u velocities and a numpy\\n array with v velocities. First we get the U and V fields from the dataset. Then\\n we compute a time chunk, which is needed because of the dataset. Then we only\\n take the first slice of the U and V field (we do not need more for finding the land\\n and ocean grids). As last we make an empty array which will be filled with zeros and \\n ones.\\n \\\"\\\"\\\"\\n fU = Fieldset.U\\n fV = Fieldset.V\\n Fieldset.computeTimeChunk(fU.grid.time[0], 1) \\n uvel_mask_c = fU.data[0,:,:] \\n vvel_mask_c = fV.data[0,:,:]\\n# vvel_mask_c = np.roll(vvel_mask_c, 1, axis = 0)\\n landmask = np.zeros((uvel_mask_c.shape[0], uvel_mask_c.shape[1]))\\n \\n \\\"\\\"\\\"\\n The first loop checks the value of the u and v velocitites. Notice that we get the\\n values of two adjacent grid, since we're working with a C-grid.\\n Visualizations of velocities in the C-grids(see below). So for a grid to be flagged identified\\n as a land grid two U velocities and 2 V velocities need to be zero. The first loop makes all\\n ocean grids 1 and land grids 0. \\n ____ ____ ____ ____\\n | V | V | \\n | | | \\n U T U T U\\n | | | \\n |____V____|_____V_____| \\n \\\"\\\"\\\"\\n \\n for i in range (len(landmask[:,0])-1):\\n for j in range (len(landmask[0,:])-1):\\n u1 = uvel_mask_c[i,j]\\n\\n u2 = uvel_mask_c[i,j+1]\\n\\n v1 = vvel_mask_c[i,j]\\n\\n v2 = vvel_mask_c[i+1,j]\\n\\n if u1 != 0 or u2 != 0 or v1 != 0 or v2 != 0:\\n landmask[i,j] = 1\\n \\n \\n \\\"\\\"\\\"\\n Change all zero to 1 and rest 0. since we want the land grids to be 1 and ocean\\n grids to be 0. \\n \\\"\\\"\\\"\\n \\n landmask = ChangeValues(landmask,0,1) \\n \\n \\\"\\\"\\\"\\n The created landmask needs to be shifted upwards one grid. We will\\n use the numpy roll function to do this.\\n \\\"\\\"\\\"\\n \\n if test == True:\\n plt.figure()\\n plt.imshow(landmask)\\n plt.colorbar()\\n \\n return landmask\",\n \"def setup_localxyzs(self):\\n self.localxyzs = [sp.vscl(1.0/v[2],v) for v in self.uvlclxyzs]\\n self.fovsides = list()\\n lastxyz = self.localxyzs[-1]\\n for xyz in self.localxyzs:\\n self.fovsides.append(FOVSIDE(xyz,lastxyz))\\n lastxyz = xyz\",\n \"def find_potential(n=10,nwalks=200):\\n \\n boundary = np.zeros((n+1, n+1)) # Store boundary potentials\\n v = np.zeros((n+1, n+1)) # Store potential for all positions\\n \\n # Set the boundary conditions\\n for i in range(1,n):\\n boundary[0,i] = 10\\n boundary[n,i] = 10\\n boundary[i,0] = 5\\n boundary[i,n] = 5\\n # Set the the boundary position that maximizes the potential at [3, 5] to 20\\n boundary[3,0] = boundary[4,0] = boundary[5,0] = boundary[6,0] = boundary[7,0] = 20\\n #boundary[0,3] = boundary[0,4] = boundary[0,5] = boundary[0,6] = boundary[0,7] = 20\\n \\n v = np.copy(boundary) # Store potential for all positions\\n\\n # Compute Greens function for each position\\n for x in range(1,n):\\n for y in range(1,n):\\n position = [x, y] # Position to compute Greens function for\\n Greens_func = Greens_function_approxRW(n=n, nwalks=nwalks, start_position=position) # The Greens function\\n \\n # Find potential at current position\\n v_pos = potential_from_Greens(boundary, n=n, G=Greens_func, nwalks=nwalks)\\n v[position[1], position[0]] = v_pos\\n \\n # v is now computed for all locations and can be plotted\\n fig = plt.figure()\\n plt.title('Maximized potential for [3,5]', fontsize = 18)\\n im = plt.imshow(v, cmap=None, interpolation='nearest')\\n cb = fig.colorbar(im)\\n cb.ax.tick_params(labelsize=14)\\n plt.show()\",\n \"def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\\n ratio_x = 0\\n ratio_y = 0\\n ratio_z = 0\\n # helm_B = [0,0,0]\\n divideby = 0\\n for shot in range(shot_range[0], shot_range[1]+1):\\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\\n ratio_x = ratio_x + x\\n ratio_y = ratio_y + y\\n ratio_z = ratio_z + z\\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\\n divideby = divideby + 1 #averaging over the number of shots\\n ratio_Bx = ratio_x/divideby\\n ratio_By = ratio_y/divideby\\n ratio_Bz = ratio_z/divideby\\n # helmB = [helm_B]/divideby\\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\\n # print(\\\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\\\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\\n Bx_sqr =ratio_x**2\\n By_sqr =ratio_y**2\\n Bz_sqr =ratio_z**2\\n B = Bx_sqr + By_sqr+ Bz_sqr\\n norm_factor = np.sqrt(B)\\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\\n\\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)\",\n \"def sph(vs, ucs, A, C, x, y, z, rotx=0, roty=0, rotz=0, mode=\\\"C\\\"):\\n sph = []\\n\\n if mode == \\\"A\\\":\\n nA = (A-0.07)/(0.12-0.07)\\n nC = (C+0.1)/(0.31+0.1)\\n elif mode == \\\"C\\\":\\n nA = (A-0.07)/(0.12-0.07)\\n nC = C/0.307\\n elif mode == \\\"AC\\\":\\n nA = (A-0.07)/(0.12-0.07)\\n nC = (C+0.1)/(0.31+0.1)\\n else:\\n nA = (A-0.07)/(0.12-0.07)\\n nC = C/0.307\\n\\n if (type(nA) is np.float64):\\n nA = np.full(len(vs), nA)\\n if (type(nC) is np.float64):\\n nC = np.full(len(vs), nC)\\n\\n for v, uc, a, c in zip(vs, ucs, nA, nC):\\n if mode == \\\"A\\\":\\n H0 = a\\n L0 = 1/(1+np.exp((-2.8*((a-0.52)*2.4))))\\n # R0, G0, B0 = colorsys.hls_to_rgb(0.02+H0*0.35, 0.5-L0*0.4, 1.0)\\n R0, G0, B0 = colorsys.hls_to_rgb(1.0-H0*0.40, 0.5-L0*0.4, 1.0)\\n\\n elif mode == \\\"C\\\":\\n H0 = c\\n L0 = 1/(1+np.exp((-2.8*((c-0.52)*2.4))))\\n R0, G0, B0 = colorsys.hls_to_rgb(0.02+H0*0.35, 0.5-L0*0.4, 1.0)\\n\\n elif mode == \\\"AC\\\":\\n R0 = a*1.0\\n # G0 = max(0.8-(max(a+c, 0)), 0)\\n G0 = 0.0\\n B0 = c*1.0\\n\\n else:\\n R0 = 0.3\\n G0 = 0.2\\n B0 = 0.2\\n\\n R1 = 1.0 - R0\\n G1 = 1.0 - G0\\n B1 = 1.0 - B0\\n\\n sph.append(Sphere(v, 0.022,\\n Texture(Pigment('color',\\n [R0+uc*R1, G0+uc*G1, B0+uc*B1]),\\n Finish('phong', 0.7,\\n 'specular', 0.2,\\n 'diffuse', 0.9,\\n 'ambient', 0.1)),\\n 'rotate', [rotx, 0, 0],\\n 'rotate', [0, roty, 0],\\n 'rotate', [0, 0, rotz],\\n 'translate', [x, y, z],\\n 'no_shadow'))\\n\\n return sph\",\n \"def compute_magnetic_field(self, coords, params=None, basis=\\\"rpz\\\"):\\n return self._scalar * self._field.compute_magnetic_field(coords, params, basis)\",\n \"def velocity_field(xt,yt,x0,y0,Vinf,dia,rot,chord,B,param=None,veltype='all',integration='simp',m=220,n=200):\\n rad = dia/2.\\n tsr = rad*fabs(rot)/Vinf\\n solidity = (chord*B)/rad\\n\\n # Translating the turbine position\\n x0t = x0 - xt\\n y0t = y0 - yt\\n\\n coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9 = coef_val()\\n\\n # Calculating EMG distribution parameters (based on polynomial surface fitting)\\n if param is None:\\n loc1 = _parameterval(tsr,solidity,coef0)\\n loc2 = _parameterval(tsr,solidity,coef1)\\n loc3 = _parameterval(tsr,solidity,coef2)\\n spr1 = _parameterval(tsr,solidity,coef3)\\n spr2 = _parameterval(tsr,solidity,coef4)\\n skw1 = _parameterval(tsr,solidity,coef5)\\n skw2 = _parameterval(tsr,solidity,coef6)\\n scl1 = _parameterval(tsr,solidity,coef7)\\n scl2 = _parameterval(tsr,solidity,coef8)\\n scl3 = _parameterval(tsr,solidity,coef9)\\n\\n else:\\n # Reading in EMG distribution parameters\\n loc1 = param[0]\\n loc2 = param[1]\\n loc3 = param[2]\\n spr1 = param[3]\\n spr2 = param[4]\\n skw1 = param[5]\\n skw2 = param[6]\\n scl1 = param[7]\\n scl2 = param[8]\\n scl3 = param[9]\\n\\n ###################################\\n if veltype == 'vort':\\n # VORTICITY CALCULATION (NO INTEGRATION)\\n if x0t < 0.:\\n vel = 0.\\n else:\\n vel = _vawtwake.vorticitystrength(x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)/rot\\n ###################################\\n else:\\n # Integration of the vorticity profile to calculate velocity\\n if integration == 'simp':\\n # SIMPSON'S RULE INTEGRATION (must use polynomial surface coefficients from VAWTPolySurfaceCoef.csv)\\n inte = 1 # Simpson's Rule\\n # inte = 2 # Trapezoidal Rule (optional ability of the code-- faster but less accurate)\\n\\n if param is not None:\\n print \\\"**** Using polynomial surface coefficients from VAWTPolySurfaceCoef.csv for Simpson's rule integration ****\\\"\\n\\n vel_xs,vel_ys = _vawtwake.vel_field(xt,yt,x0,y0,dia,rot,chord,B,Vinf,coef0,coef1,coef2,coef3,coef4,coef5,coef6,coef7,coef8,coef9,m,n,inte)\\n\\n if veltype == 'all':\\n vel = sqrt((vel_xs*Vinf + Vinf)**2 + (vel_ys*Vinf)**2)/Vinf\\n elif veltype == 'x':\\n vel = (vel_xs*Vinf + Vinf)/Vinf\\n elif veltype == 'y':\\n vel = vel_ys\\n elif veltype == 'ind':\\n vel = np.array([vel_xs,vel_ys])\\n ###################################\\n elif integration == 'gskr':\\n # 21-POINT GAUSS-KRONROD RULE QUADRATURE INTEGRATION\\n xbound = (scl3+5.)*dia\\n argval = (x0t,y0t,dia,loc1,loc2,loc3,spr1,spr2,skw1,skw2,scl1,scl2,scl3)\\n if veltype == 'all' or veltype == 'x' or veltype == 'ind':\\n vel_x = _dblquad(_vawtwake.integrandx,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\\n vel_xs = (vel_x[0]*fabs(rot))/(2.*pi)\\n if veltype == 'all' or veltype == 'y' or veltype == 'ind':\\n vel_y = _dblquad(_vawtwake.integrandy,0.,xbound,lambda x: -1.*dia,lambda x: 1.*dia,args=argval)\\n vel_ys = (vel_y[0]*fabs(rot))/(2.*pi)\\n\\n if veltype == 'all':\\n vel = sqrt((vel_xs + Vinf)**2 + (vel_ys)**2)/Vinf\\n elif veltype == 'x':\\n vel = (vel_xs + Vinf)/Vinf\\n elif veltype == 'y':\\n vel = vel_ys/Vinf\\n elif veltype == 'ind':\\n vel = np.array([vel_xs,vel_ys])/Vinf\\n ###################################\\n\\n return vel\",\n \"def move_to_point_and_extract(coords_from_to: list,\\n gps: adapters.GPSUbloxAdapter,\\n vesc_engine: adapters.VescAdapterV4,\\n smoothie: adapters.SmoothieAdapter,\\n camera: adapters.CameraAdapterIMX219_170,\\n periphery_det: detection.YoloOpenCVDetection,\\n precise_det: detection.YoloOpenCVDetection,\\n logger_full: utility.Logger,\\n report_field_names,\\n trajectory_saver: utility.TrajectorySaver,\\n working_zone_polygon,\\n img_output_dir,\\n nav: navigation.GPSComputing,\\n data_collector: datacollection.DataCollector,\\n log_cur_dir,\\n image_saver: utility.ImageSaver,\\n notification: NotificationClient,\\n extraction_manager_v3: ExtractionManagerV3,\\n ui_msg_queue: posix_ipc.MessageQueue,\\n SI_speed: float,\\n wheels_straight: bool,\\n navigation_prediction: navigation.NavigationPrediction,\\n future_points: list,\\n allow_extractions: bool,\\n x_scan_poly: list,\\n cur_field):\\n\\n if config.ALLOW_FIELD_LEAVING_PROTECTION and cur_field is not None and len(cur_field) > 2:\\n enable_field_leaving_protection = True\\n else:\\n enable_field_leaving_protection = False\\n if config.ALLOW_FIELD_LEAVING_PROTECTION:\\n if cur_field is None:\\n msg = f\\\"WARNING: robot field leaving protection WILL NOT WORK as given field is None\\\"\\n print(msg)\\n logger_full.write(msg)\\n elif len(cur_field) < 3:\\n msg = f\\\"WARNING: robot field leaving protection WILL NOT WORK as given field contains \\\" \\\\\\n f\\\"{len(cur_field)} points (required ar least 3 points)\\\"\\n print(msg)\\n logger_full.write(msg)\\n\\n extract = SI_speed > 0 and allow_extractions\\n\\n vesc_speed = SI_speed * config.MULTIPLIER_SI_SPEED_TO_RPM\\n speed_fast = config.SI_SPEED_FAST * config.MULTIPLIER_SI_SPEED_TO_RPM\\n vesc_speed_fast = speed_fast if SI_speed >= 0 else -speed_fast\\n navigation_prediction.set_SI_speed(SI_speed)\\n\\n raw_angles_history = []\\n detections_period = []\\n navigations_period = []\\n stop_helping_point = nav.get_coordinate(\\n coords_from_to[1], coords_from_to[0], 90, 1000)\\n learn_go_straight_index = 0\\n learn_go_straight_history = []\\n\\n last_skipped_point = coords_from_to[0]\\n start_Nav_while = True\\n last_correct_raw_angle = 0\\n point_status = \\\"origin\\\"\\n last_corridor_side = 0\\n current_corridor_side = 1\\n almost_start = 0\\n\\n prev_maneuver_time = time.time()\\n working_mode_slow = 1\\n working_mode_fast = 2\\n working_mode_switching = 3\\n current_working_mode = working_mode_slow\\n last_working_mode = 0\\n # True if robot is close to one of current movement vector points, False otherwise; False if speed limit near points is disabled\\n close_to_end = config.USE_SPEED_LIMIT\\n bumper_is_pressed = None\\n\\n # message queue sending temporary performance tracker\\n if config.QUEUE_TRACK_PERFORMANCE:\\n ui_msg_queue_perf = {\\n \\\"max_time\\\": 0,\\n \\\"min_time\\\": float(\\\"inf\\\"),\\n \\\"total_time\\\": 0,\\n \\\"total_sends\\\": 0,\\n \\\"timeouts_exceeded\\\": 0\\n }\\n\\n # x movements during periphery scans\\n x_scan_cur_idx = 0\\n x_scan_idx_increasing = True\\n\\n # set camera to the Y min\\n res = smoothie.custom_separate_xy_move_to(X_F=config.X_F_MAX,\\n Y_F=config.Y_F_MAX,\\n X=smoothie.smoothie_to_mm(\\n (config.X_MAX - config.X_MIN) / 2, \\\"X\\\"),\\n Y=smoothie.smoothie_to_mm(config.Y_MIN, \\\"Y\\\"))\\n if res != smoothie.RESPONSE_OK:\\n msg = \\\"INIT: Failed to move camera to Y min, smoothie response:\\\\n\\\" + res\\n logger_full.write(msg + \\\"\\\\n\\\")\\n smoothie.wait_for_all_actions_done()\\n\\n # TODO: maybe should add sleep time as camera currently has delay\\n\\n if config.AUDIT_MODE:\\n vesc_engine.set_target_rpm(vesc_speed, vesc_engine.PROPULSION_KEY)\\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\\n\\n try:\\n notificationQueue = posix_ipc.MessageQueue(\\n config.QUEUE_NAME_UI_NOTIFICATION)\\n except KeyboardInterrupt:\\n raise KeyboardInterrupt\\n except:\\n notificationQueue = None\\n\\n degraded_navigation_mode = False\\n\\n number_navigation_cycle_without_gps = 0\\n\\n point_reading_t = last_send_gps_time = slow_mode_time = time.time()\\n\\n have_time_for_inference = True\\n predictor_next_gps_expected_ts = float(\\\"inf\\\")\\n\\n # main navigation control loop\\n while True:\\n # gps point reading time predictor\\n if have_time_for_inference and config.ALLOW_GPS_TIME_PREDICTIONS_LIMITING_INFERENCE:\\n if time.time() + config.INFERENCE_MAX_TICK_TIME > predictor_next_gps_expected_ts:\\n have_time_for_inference = False\\n\\n if have_time_for_inference:\\n # EXTRACTION CONTROL\\n start_t = time.time()\\n frame = camera.get_image()\\n frame_t = time.time()\\n\\n per_det_start_t = time.time()\\n if extract:\\n plants_boxes = periphery_det.detect(frame)\\n else:\\n plants_boxes = list()\\n per_det_end_t = time.time()\\n detections_period.append(per_det_end_t - start_t)\\n\\n if config.SAVE_DEBUG_IMAGES:\\n image_saver.save_image(\\n frame,\\n img_output_dir,\\n label=\\\"PE_view_M=\\\" + str(current_working_mode),\\n plants_boxes=plants_boxes)\\n if config.ALLOW_GATHERING and current_working_mode == working_mode_slow and \\\\\\n image_saver.get_counter(\\\"gathering\\\") < config.DATA_GATHERING_MAX_IMAGES:\\n image_saver.save_image(frame, config.DATA_GATHERING_DIR,\\n plants_boxes=plants_boxes, counter_key=\\\"gathering\\\")\\n\\n if extract:\\n msg = \\\"View frame time: \\\" + str(frame_t - start_t) + \\\"\\\\t\\\\tPeri. det. time: \\\" + \\\\\\n str(per_det_end_t - per_det_start_t)\\n else:\\n msg = \\\"View frame time: \\\" + str(frame_t - start_t) + \\\"\\\\t\\\\tPeri. det. (extractions are off) time: \\\" + \\\\\\n str(per_det_end_t - per_det_start_t)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n\\n # MOVEMENT AND ACTIONS MODES\\n if config.AUDIT_MODE:\\n dc_start_t = time.time()\\n\\n # count detected plant boxes for each type\\n plants_count = dict()\\n for plant_box in plants_boxes:\\n plant_box_name = plant_box.get_name()\\n if plant_box_name in plants_count:\\n plants_count[plant_box_name] += 1\\n else:\\n plants_count[plant_box_name] = 1\\n\\n # save info into data collector\\n for plant_label in plants_count:\\n data_collector.add_detections_data(plant_label,\\n math.ceil((plants_count[plant_label]) / config.AUDIT_DIVIDER))\\n\\n # flush updates into the audit output file and log measured time\\n if len(plants_boxes) > 0:\\n data_collector.save_all_data(\\n log_cur_dir + config.AUDIT_OUTPUT_FILE)\\n\\n dc_t = time.time() - dc_start_t\\n msg = \\\"Last scan weeds detected: \\\" + str(len(plants_boxes)) + \\\\\\n \\\", audit processing tick time: \\\" + str(dc_t)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n else:\\n # slow mode\\n if current_working_mode == working_mode_slow:\\n if last_working_mode != current_working_mode:\\n last_working_mode = current_working_mode\\n msg = \\\"[Working mode] : slow\\\"\\n if config.LOG_SPEED_MODES:\\n logger_full.write(msg + \\\"\\\\n\\\")\\n if config.PRINT_SPEED_MODES:\\n print(msg)\\n\\n if ExtractionManagerV3.any_plant_in_zone(\\n plants_boxes,\\n x_scan_poly[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else working_zone_polygon):\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n if config.VERBOSE_EXTRACT:\\n msg = \\\"[VERBOSE EXTRACT] Stopping the robot because we have detected plant(s).\\\"\\n logger_full.write_and_flush(msg+\\\"\\\\n\\\")\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n # TODO this 0 rpm \\\"movement\\\" is to prevent robot movement during extractions, need to add this in future to rest speed modes too\\n vesc_engine.set_time_to_move(config.VESC_MOVING_TIME, vesc_engine.PROPULSION_KEY)\\n vesc_engine.set_target_rpm(0, vesc_engine.PROPULSION_KEY)\\n vesc_engine.set_current_rpm(0, vesc_engine.PROPULSION_KEY)\\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\\n\\n # TODO remove thread init from here!\\n voltage_thread = threading.Thread(\\n target=send_voltage_thread_tf,\\n args=(vesc_engine, ui_msg_queue),\\n daemon=True)\\n voltage_thread.start()\\n\\n # single precise center scan before calling for PDZ scanning and extractions\\n if config.ALLOW_PRECISE_SINGLE_SCAN_BEFORE_PDZ and not config.ALLOW_X_MOVEMENT_DURING_SCANS:\\n time.sleep(config.DELAY_BEFORE_2ND_SCAN)\\n frame = camera.get_image()\\n plants_boxes = precise_det.detect(frame)\\n\\n # do PDZ scan and extract all plants if single precise scan got plants in working area\\n if ExtractionManagerV3.any_plant_in_zone(plants_boxes, working_zone_polygon):\\n if config.EXTRACTION_MODE == 1:\\n extraction_manager_v3.extract_all_plants()\\n elif config.EXTRACTION_MODE == 2:\\n extraction_manager_v3.mill_all_plants()\\n slow_mode_time = time.time()\\n else:\\n if config.EXTRACTION_MODE == 1:\\n extraction_manager_v3.extract_all_plants()\\n elif config.EXTRACTION_MODE == 2:\\n extraction_manager_v3.mill_all_plants()\\n slow_mode_time = time.time()\\n\\n if config.VERBOSE_EXTRACT:\\n msg = \\\"[VERBOSE EXTRACT] Extract cycle are finish.\\\"\\n logger_full.write_and_flush(msg+\\\"\\\\n\\\")\\n\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n\\n msg = \\\"Applying force step forward after extractions cycle(s)\\\"\\n logger_full.write(msg + \\\"\\\\n\\\")\\n if config.VERBOSE:\\n print(msg)\\n vesc_engine.set_time_to_move(config.STEP_FORWARD_TIME, vesc_engine.PROPULSION_KEY)\\n vesc_engine.set_target_rpm(\\n config.SI_SPEED_STEP_FORWARD * config.MULTIPLIER_SI_SPEED_TO_RPM,\\n vesc_engine.PROPULSION_KEY)\\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\\n vesc_engine.wait_for_stop(vesc_engine.PROPULSION_KEY)\\n\\n elif config.SLOW_FAST_MODE and time.time() - slow_mode_time > config.SLOW_MODE_MIN_TIME:\\n # move cork to fast mode scan position\\n if config.VERBOSE:\\n msg = \\\"SLOW MODE: moving cork to fast mode position\\\\n\\\"\\n logger_full.write(msg)\\n\\n res = smoothie.custom_separate_xy_move_to(\\n X_F=config.X_F_MAX,\\n Y_F=config.Y_F_MAX,\\n X=smoothie.smoothie_to_mm(\\n (config.X_MAX - config.X_MIN) / 2, \\\"X\\\"),\\n Y=smoothie.smoothie_to_mm((config.Y_MAX - config.Y_MIN) * config.SLOW_FAST_MODE_HEAD_FACTOR,\\n \\\"Y\\\"))\\n if res != smoothie.RESPONSE_OK:\\n msg = \\\"INIT: Keeping in slow mode as failed to move camera to fast mode scan position, smoothie's response:\\\\n\\\" + res\\n logger_full.write(msg + \\\"\\\\n\\\")\\n else:\\n msg = \\\"Switching from 'slow mode' to 'switching mode'\\\"\\n if config.LOG_SPEED_MODES:\\n logger_full.write(msg + \\\"\\\\n\\\")\\n if config.PRINT_SPEED_MODES:\\n print(msg)\\n current_working_mode = working_mode_switching\\n\\n # TODO a bug: will not start moving if config.SLOW_MODE_MIN_TIME == 0 or too low (switch speed applies right after slow mode weeds extractions)\\n if not vesc_engine.is_moving(vesc_engine.PROPULSION_KEY):\\n vesc_engine.set_time_to_move(config.VESC_MOVING_TIME, vesc_engine.PROPULSION_KEY)\\n vesc_engine.set_target_rpm(vesc_speed, vesc_engine.PROPULSION_KEY)\\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\\n\\n # switching (from slow to fast) mode\\n elif current_working_mode == working_mode_switching:\\n if last_working_mode != current_working_mode:\\n last_working_mode = current_working_mode\\n msg = \\\"[Working mode] : switching to fast\\\"\\n if config.LOG_SPEED_MODES:\\n logger_full.write(msg + \\\"\\\\n\\\")\\n if config.PRINT_SPEED_MODES:\\n print(msg)\\n\\n if ExtractionManagerV3.any_plant_in_zone(\\n plants_boxes,\\n x_scan_poly[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else working_zone_polygon):\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n\\n if config.VERBOSE:\\n msg = \\\"Moving cork to slow mode scan position\\\\n\\\"\\n logger_full.write(msg)\\n\\n # smoothie.wait_for_all_actions_done()\\n res = smoothie.custom_separate_xy_move_to(\\n X_F=config.X_F_MAX,\\n Y_F=config.Y_F_MAX,\\n X=smoothie.smoothie_to_mm(\\n (config.X_MAX - config.X_MIN) / 2, \\\"X\\\"),\\n Y=smoothie.smoothie_to_mm(config.Y_MIN, \\\"Y\\\"))\\n if res != smoothie.RESPONSE_OK:\\n msg = \\\"INIT: Failed to move camera to Y min, smoothie response:\\\\n\\\" + res\\n logger_full.write(msg + \\\"\\\\n\\\")\\n smoothie.wait_for_all_actions_done()\\n\\n current_working_mode = working_mode_slow\\n slow_mode_time = time.time()\\n vesc_engine.set_target_rpm(\\n vesc_speed, vesc_engine.PROPULSION_KEY)\\n continue\\n\\n sm_cur_pos = smoothie.get_smoothie_current_coordinates(\\n convert_to_mms=False)\\n if abs(sm_cur_pos[\\\"X\\\"] - (config.X_MAX - config.X_MIN) / 2) < 0.001 and \\\\\\n abs(sm_cur_pos[\\\"Y\\\"] - (config.Y_MAX - config.Y_MIN) * config.SLOW_FAST_MODE_HEAD_FACTOR) < 0.001:\\n msg = \\\"Switching from 'switching mode' to 'fast mode'\\\"\\n if config.LOG_SPEED_MODES:\\n logger_full.write(msg + \\\"\\\\n\\\")\\n if config.PRINT_SPEED_MODES:\\n print(msg)\\n current_working_mode = working_mode_fast\\n\\n # fast mode\\n elif current_working_mode == working_mode_fast:\\n if last_working_mode != current_working_mode:\\n last_working_mode = current_working_mode\\n msg = \\\"[Working mode] : fast\\\"\\n if config.LOG_SPEED_MODES:\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n if config.PRINT_SPEED_MODES:\\n print(msg)\\n\\n if ExtractionManagerV3.any_plant_in_zone(\\n plants_boxes,\\n x_scan_poly[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else working_zone_polygon):\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n\\n if config.VERBOSE:\\n msg = \\\"Moving cork to slow mode scan position\\\\n\\\"\\n logger_full.write(msg)\\n\\n # smoothie.wait_for_all_actions_done()\\n res = smoothie.custom_separate_xy_move_to(\\n X_F=config.X_F_MAX,\\n Y_F=config.Y_F_MAX,\\n X=smoothie.smoothie_to_mm(\\n (config.X_MAX - config.X_MIN) / 2, \\\"X\\\"),\\n Y=smoothie.smoothie_to_mm(config.Y_MIN, \\\"Y\\\"))\\n if res != smoothie.RESPONSE_OK:\\n msg = \\\"INIT: Failed to move camera to Y min, smoothie response:\\\\n\\\" + res\\n logger_full.write(msg + \\\"\\\\n\\\")\\n smoothie.wait_for_all_actions_done()\\n\\n msg = \\\"Switching from 'fast mode' to 'slow mode'\\\"\\n if config.LOG_SPEED_MODES:\\n logger_full.write(msg + \\\"\\\\n\\\")\\n if config.PRINT_SPEED_MODES:\\n print(msg)\\n current_working_mode = working_mode_slow\\n slow_mode_time = time.time()\\n # TODO dont need anymore? as rpm is set at the end of slow mode\\n # vesc_engine.set_rpm(vesc_speed, vesc_engine.PROPULSION_KEY)\\n continue\\n elif close_to_end:\\n cur_vesc_rpm = vesc_engine.get_current_rpm(\\n vesc_engine.PROPULSION_KEY)\\n if cur_vesc_rpm != vesc_speed:\\n msg = f\\\"Applying slow speed {vesc_speed} at 'fast mode' \\\" \\\\\\n f\\\"(was {cur_vesc_rpm}) \\\" \\\\\\n f\\\"because of close_to_end flag trigger\\\"\\n if config.LOG_SPEED_MODES:\\n logger_full.write(msg + \\\"\\\\n\\\")\\n if config.PRINT_SPEED_MODES:\\n print(msg)\\n vesc_engine.set_target_rpm(\\n vesc_speed, vesc_engine.PROPULSION_KEY)\\n vesc_engine.set_current_rpm(\\n vesc_speed, vesc_engine.PROPULSION_KEY)\\n else:\\n cur_vesc_rpm = vesc_engine.get_current_rpm(\\n vesc_engine.PROPULSION_KEY)\\n if cur_vesc_rpm != vesc_speed_fast:\\n msg = f\\\"Applying fast speed {vesc_speed_fast} at 'fast mode' (was {cur_vesc_rpm})\\\"\\n if config.LOG_SPEED_MODES:\\n logger_full.write(msg + \\\"\\\\n\\\")\\n if config.PRINT_SPEED_MODES:\\n print(msg)\\n vesc_engine.set_target_rpm(\\n vesc_speed_fast, vesc_engine.PROPULSION_KEY)\\n vesc_engine.set_current_rpm(\\n vesc_speed_fast, vesc_engine.PROPULSION_KEY)\\n\\n # NAVIGATION CONTROL\\n cur_pos_obj = gps.get_last_position_v2()\\n cur_pos = cur_pos_obj.as_old_list\\n\\n nav_start_t = time.time()\\n\\n if start_Nav_while:\\n navigation_period = 1\\n else:\\n navigation_period = nav_start_t - prev_maneuver_time\\n\\n navigations_period.append(navigation_period)\\n # time reference to decide the number of detection before resuming gps.get\\n prev_maneuver_time = nav_start_t\\n # print(\\\"tock\\\")\\n\\n if start_Nav_while:\\n prev_pos_obj = cur_pos_obj\\n prev_pos = prev_pos_obj.as_old_list\\n start_Nav_while = False\\n\\n # mu_navigations_period, sigma_navigations_period = utility.mu_sigma(navigations_period)\\n\\n navigation_prediction.set_current_lat_long(cur_pos)\\n\\n # skip same points (non-blocking reading returns old point if new point isn't available yet)\\n if math.isclose(cur_pos_obj.creation_ts, prev_pos_obj.creation_ts):\\n # stop robot if there's no new points for a while\\n if time.time() - point_reading_t > config.GPS_POINT_TIME_BEFORE_STOP:\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n msg = f\\\"Stopping the robot due to exceeding time 'GPS_POINT_TIME_BEFORE_STOP=\\\" \\\\\\n f\\\"{config.GPS_POINT_TIME_BEFORE_STOP}' limit without new gps points from adapter\\\"\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n\\n gps_reconnect_ts = time.time()\\n\\n while True:\\n cur_pos_obj = gps.get_last_position_v2()\\n cur_pos = cur_pos_obj.as_old_list\\n\\n if math.isclose(cur_pos_obj.creation_ts, prev_pos_obj.creation_ts):\\n # reconnect gps adapter to ublox if there's no gps points for a while\\n if time.time() - gps_reconnect_ts > config.GPS_POINT_TIME_BEFORE_RECONNECT:\\n gps.reconnect()\\n gps_reconnect_ts = time.time()\\n msg = \\\"Called GPS adapter to reconnect to ublox due to waiting too much for a new GPS \\\" \\\\\\n \\\"point (new points filter)\\\"\\n if config.VERBOSE:\\n print(msg)\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n else:\\n msg = \\\"New GPS point received, continuing movement\\\"\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\\n break\\n else:\\n continue\\n\\n # gps points reading time predictor\\n predictor_next_gps_expected_ts = cur_pos_obj.receiving_ts + config.GPS_POINT_WAIT_TIME_MAX\\n have_time_for_inference = True\\n\\n # points filter by quality flag\\n if cur_pos[2] != \\\"4\\\" and config.ALLOW_GPS_BAD_QUALITY_NTRIP_RESTART:\\n # restart ntrip if enough time passed since the last ntrip restart\\n navigation.NavigationV3.restart_ntrip_service(logger_full)\\n\\n # stop robot due to bad point quality if allowed\\n if config.ALLOW_GPS_BAD_QUALITY_STOP:\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n logger_full.write_and_flush(\\n \\\"Stopping the robot for lack of quality gps 4, waiting for it...\\\\n\\\")\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n\\n prev_bad_quality_pos_obj = cur_pos_obj\\n gps_reconnect_ts = time.time()\\n\\n while True:\\n cur_pos_obj = gps.get_last_position_v2()\\n cur_pos = cur_pos_obj.as_old_list\\n\\n # check if it's a new point\\n if math.isclose(cur_pos_obj.creation_ts, prev_bad_quality_pos_obj.creation_ts):\\n # reconnect gps adapter to ublox if there's no gps points for a while\\n if time.time() - gps_reconnect_ts > config.GPS_POINT_TIME_BEFORE_RECONNECT:\\n gps.reconnect()\\n gps_reconnect_ts = time.time()\\n msg = \\\"Called GPS adapter to reconnect to ublox due to waiting too much for a new \\\" \\\\\\n \\\"GPS point (quality filter)\\\"\\n if config.VERBOSE:\\n print(msg)\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n continue\\n else:\\n prev_bad_quality_pos_obj = cur_pos_obj\\n\\n # check if it's a good quality point\\n if cur_pos[2] != \\\"4\\\":\\n # restart ntrip if enough time passed since the last ntrip restart\\n navigation.NavigationV3.restart_ntrip_service(\\n logger_full)\\n else:\\n msg = \\\"The gps has regained quality 4, starting movement\\\"\\n if config.VERBOSE:\\n print(msg)\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\\n break\\n\\n # points filter by distance\\n prev_cur_distance = nav.get_distance(prev_pos, cur_pos)\\n if config.ALLOW_GPS_PREV_CUR_DIST_STOP and prev_cur_distance > config.PREV_CUR_POINT_MAX_DIST:\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n msg = f\\\"Stopping the robot due to GPS points filter by distance (assuming current position point \\\" \\\\\\n f\\\"{str(cur_pos)} is wrong as distance between current position and prev. position {str(prev_pos)}\\\" \\\\\\n f\\\" is bigger than config.PREV_CUR_POINT_MAX_DIST={str(config.PREV_CUR_POINT_MAX_DIST)})\\\"\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n\\n prev_bad_quality_pos_obj = cur_pos_obj\\n gps_reconnect_ts = distance_wait_start_ts = time.time()\\n\\n while True:\\n if time.time() - distance_wait_start_ts > config.GPS_DIST_WAIT_TIME_MAX:\\n msg = f\\\"Stopping waiting for good prev-cur distance due to timeout, using current point \\\" \\\\\\n f\\\"{cur_pos} and starting moving again\\\"\\n if config.VERBOSE:\\n print(msg)\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\\n break\\n\\n cur_pos_obj = gps.get_last_position_v2()\\n cur_pos = cur_pos_obj.as_old_list\\n\\n # check if it's a new point\\n if math.isclose(cur_pos_obj.creation_ts, prev_bad_quality_pos_obj.creation_ts):\\n # reconnect gps adapter to ublox if there's no gps points for a while\\n if time.time() - gps_reconnect_ts > config.GPS_POINT_TIME_BEFORE_RECONNECT:\\n gps.reconnect()\\n gps_reconnect_ts = time.time()\\n msg = \\\"Called GPS adapter to reconnect to ublox due to waiting too much for a new \\\" \\\\\\n \\\"GPS point (distance filter)\\\"\\n if config.VERBOSE:\\n print(msg)\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n continue\\n else:\\n prev_bad_quality_pos_obj = cur_pos_obj\\n\\n # check if it's a good quality point or ignore point quality if bad quality stop is not allowed\\n if cur_pos[2] != \\\"4\\\" and config.ALLOW_GPS_BAD_QUALITY_NTRIP_RESTART:\\n # restart ntrip if enough time passed since the last ntrip restart\\n navigation.NavigationV3.restart_ntrip_service(logger_full)\\n continue\\n\\n # check if distance became ok\\n prev_cur_distance = nav.get_distance(prev_pos, cur_pos)\\n if prev_cur_distance <= config.PREV_CUR_POINT_MAX_DIST:\\n msg = f\\\"Starting moving again after GPS points filter by distance as distance become OK \\\" \\\\\\n f\\\"({str(prev_cur_distance)})\\\"\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n vesc_engine.start_moving(vesc_engine.PROPULSION_KEY)\\n break\\n\\n point_reading_t = time.time()\\n\\n trajectory_saver.save_point(cur_pos)\\n if ui_msg_queue is not None and time.time()-last_send_gps_time >= 1:\\n try:\\n ui_msg_queue_send_ts = time.time()\\n ui_msg_queue.send(json.dumps(\\n {\\\"last_gps\\\": cur_pos}), timeout=config.QUEUE_WAIT_TIME_MAX)\\n last_send_gps_time = time.time()\\n\\n if config.QUEUE_TRACK_PERFORMANCE:\\n ui_msg_queue_send_et = last_send_gps_time - ui_msg_queue_send_ts\\n if ui_msg_queue_send_et < ui_msg_queue_perf[\\\"min_time\\\"]:\\n ui_msg_queue_perf[\\\"min_time\\\"] = ui_msg_queue_send_et\\n if ui_msg_queue_send_et > ui_msg_queue_perf[\\\"max_time\\\"]:\\n ui_msg_queue_perf[\\\"max_time\\\"] = ui_msg_queue_send_et\\n ui_msg_queue_perf[\\\"total_time\\\"] += ui_msg_queue_send_et\\n ui_msg_queue_perf[\\\"total_sends\\\"] += 1\\n except posix_ipc.BusyError:\\n msg = f\\\"Current position wasn't sent to ui_msg_queue likely due to sending timeout \\\" \\\\\\n f\\\"(max wait time: config.QUEUE_WAIT_TIME_MAX={config.QUEUE_WAIT_TIME_MAX}\\\"\\n logger_full.write(msg + \\\"\\\\n\\\")\\n\\n if config.QUEUE_TRACK_PERFORMANCE:\\n ui_msg_queue_perf[\\\"timeouts_exceeded\\\"] += 1\\n\\n if config.CONTINUOUS_INFORMATION_SENDING and not degraded_navigation_mode:\\n notification.set_current_coordinate(cur_pos)\\n\\n distance = nav.get_distance(cur_pos, coords_from_to[1])\\n\\n last_corridor_side = current_corridor_side\\n perpendicular, current_corridor_side = nav.get_deviation(\\n coords_from_to[0], coords_from_to[1], cur_pos)\\n\\n # stop the robot if it has left the field\\n if enable_field_leaving_protection:\\n for pt_idx in range(len(cur_field)):\\n last_point = pt_idx + 1 == len(cur_field)\\n\\n if last_point:\\n deviation, side = nav.get_deviation(cur_field[pt_idx], cur_field[0], cur_pos)\\n else:\\n deviation, side = nav.get_deviation(cur_field[pt_idx], cur_field[pt_idx + 1], cur_pos)\\n\\n if side == -1 and deviation > config.LEAVING_PROTECTION_DISTANCE_MAX:\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n msg = f\\\"Robot is stopped due to leaving the field. Cur pos: '{str(cur_pos)}'; \\\" \\\\\\n f\\\"Field comparison vector - P1: '{str(cur_field[pt_idx])}', \\\" \\\\\\n f\\\"P2: '{str(cur_field[0] if last_point else cur_field[pt_idx + 1])}'\\\"\\n print(msg)\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n notification.set_robot_state(RobotStates.OUT_OF_SERVICE)\\n exit()\\n\\n # check if arrived\\n _, side = nav.get_deviation(\\n coords_from_to[1], stop_helping_point, cur_pos)\\n # if distance <= config.COURSE_DESTINATION_DIFF: # old way\\n if side != 1: # TODO: maybe should use both side and distance checking methods at once\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n # msg = \\\"Arrived (allowed destination distance difference \\\" + str(config.COURSE_DESTINATION_DIFF) + \\\" mm)\\\"\\n # TODO: service will reload script even if it done his work?\\n msg = \\\"Arrived to \\\" + str(coords_from_to[1])\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n\\n # put the wheel straight\\n if wheels_straight:\\n response = smoothie.custom_move_to(A_F=config.A_F_MAX, A=0)\\n if response != smoothie.RESPONSE_OK: # TODO: what if response is not ok?\\n msg = \\\"Couldn't turn wheels to center (0), smoothie response:\\\\n\\\" + \\\\\\n response\\n print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n else:\\n # save wheels angle\\n with open(config.LAST_ANGLE_WHEELS_FILE, \\\"w+\\\") as wheels_angle_file:\\n wheels_angle_file.write(\\n str(smoothie.get_adapter_current_coordinates()[\\\"A\\\"]))\\n break\\n\\n # TODO check for bug: arrival check applies single speed for all path (while multiple speeds are applied)\\n # check if can arrived\\n if vesc_engine.get_current_rpm(vesc_engine.PROPULSION_KEY) / config.MULTIPLIER_SI_SPEED_TO_RPM * \\\\\\n config.MANEUVERS_FREQUENCY > nav.get_distance(cur_pos, coords_from_to[1]):\\n vesc_engine.stop_moving(vesc_engine.PROPULSION_KEY)\\n data_collector.add_vesc_moving_time_data(\\n vesc_engine.get_last_movement_time(vesc_engine.PROPULSION_KEY))\\n msg = \\\"Will have arrived before the next point to \\\" + \\\\\\n str(coords_from_to[1])\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n\\n break\\n\\n # reduce speed if near the target point\\n if config.USE_SPEED_LIMIT:\\n distance_from_start = nav.get_distance(coords_from_to[0], cur_pos)\\n close_to_end = distance < config.DECREASE_SPEED_TRESHOLD or distance_from_start < config.DECREASE_SPEED_TRESHOLD\\n\\n msg = \\\"Distance to B: \\\" + str(distance)\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n\\n msg = \\\"Prev: \\\" + str(prev_pos) + \\\" Cur: \\\" + str(cur_pos) + \\\" A: \\\" + str(coords_from_to[0]) \\\\\\n + \\\" B: \\\" + str(coords_from_to[1])\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n\\n # pass by cur points which are very close to prev point to prevent angle errors when robot is staying\\n # (too close points in the same position can produce false huge angles)\\n\\n navigation_prediction.run_prediction(coords_from_to, cur_pos)\\n\\n # raw_angle_cruise = nav.get_angle(coords_from_to[0], cur_pos, cur_pos, coords_from_to[1])\\n # raw_angle_legacy = nav.get_angle(prev_pos, cur_pos, cur_pos, coords_from_to[1])\\n raw_angle_centroid = nav.get_angle(\\n prev_pos, cur_pos, coords_from_to[0], coords_from_to[1])\\n raw_angle_cruise = - current_corridor_side * math.log(1+perpendicular)\\n\\n if nav.get_distance(coords_from_to[0], coords_from_to[1]) < config.CORNER_THRESHOLD and nav.get_distance(coords_from_to[1], future_points[0][0]) < config.CORNER_THRESHOLD:\\n # if abs(raw_angle_legacy)>config.LOST_THRESHOLD:\\n centroid_factor = config.CENTROID_FACTOR_LOST\\n cruise_factor = 1/centroid_factor\\n else:\\n centroid_factor = config.CENTROID_FACTOR_ORIENTED\\n cruise_factor = 1\\n\\n raw_angle = raw_angle_centroid*centroid_factor + raw_angle_cruise*cruise_factor\\n\\n # raw_angle = butter_lowpass_filter(raw_angle, 0.5, 4, 6)\\n\\n if config.LEARN_GO_STRAIGHT:\\n if config.MIN_PERPENDICULAR_GO_STRAIGHT >= perpendicular:\\n learn_go_straight_index += 1\\n learn_go_straight_history.append(raw_angle)\\n if len(learn_go_straight_history) >= config.VALUES_LEARN_GO_STRAIGHT:\\n learn_go_straight = sum(\\n learn_go_straight_history)/len(learn_go_straight_history)\\n msg = f\\\"Average angle applied to the wheel for the robot to have found : {learn_go_straight}.\\\"\\n logger_full.write_and_flush(msg + \\\"\\\\n\\\")\\n # TODO opening and closing file 4 times per second\\n with open(config.LEARN_GO_STRAIGHT_FILE, \\\"w+\\\") as learn_go_straight_file:\\n learn_go_straight_file.write(str(learn_go_straight))\\n else:\\n learn_go_straight_index = 0\\n\\n # NAVIGATION STATE MACHINE\\n if prev_cur_distance < config.PREV_CUR_POINT_MIN_DIST:\\n raw_angle = last_correct_raw_angle\\n # print(\\\"The distance covered is low\\\")\\n point_status = \\\"skipped\\\"\\n\\n # register the last position where the robot almost stop\\n # in order to disable the deviation servo for a config.POURSUIT_LIMIT length and then resume in cruise\\n last_skipped_point = cur_pos\\n else:\\n last_correct_raw_angle = raw_angle\\n point_status = \\\"correct\\\"\\n\\n almost_start = nav.get_distance(last_skipped_point, cur_pos)\\n\\n # sum(e)\\n if len(raw_angles_history) >= config.WINDOW:\\n raw_angles_history.pop(0)\\n raw_angles_history.append(raw_angle)\\n # print(\\\"len(raw_angles_history):\\\",len(raw_angles_history))\\n sum_angles = sum(raw_angles_history)\\n if sum_angles > config.SUM_ANGLES_HISTORY_MAX:\\n msg = \\\"Sum angles \\\" + str(sum_angles) + \\\" is bigger than max allowed value \\\" + \\\\\\n str(config.SUM_ANGLES_HISTORY_MAX) + \\\", setting to \\\" + \\\\\\n str(config.SUM_ANGLES_HISTORY_MAX)\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n # Get Ready to go down as soon as the angle get negatif\\n raw_angles_history[len(raw_angles_history) -\\n 1] -= sum_angles - config.SUM_ANGLES_HISTORY_MAX\\n sum_angles = config.SUM_ANGLES_HISTORY_MAX\\n elif sum_angles < -config.SUM_ANGLES_HISTORY_MAX:\\n msg = \\\"Sum angles \\\" + str(sum_angles) + \\\" is less than min allowed value \\\" + \\\\\\n str(-config.SUM_ANGLES_HISTORY_MAX) + \\\", setting to \\\" + \\\\\\n str(-config.SUM_ANGLES_HISTORY_MAX)\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n # get Ready to go up as soon as the angle get positive:\\n raw_angles_history[len(raw_angles_history)-1] += - \\\\\\n sum_angles - config.SUM_ANGLES_HISTORY_MAX\\n sum_angles = -config.SUM_ANGLES_HISTORY_MAX\\n\\n # KP = 0.2*0,55\\n # KI = 0.0092*0,91\\n\\n KP = getSpeedDependentConfigParam(\\n config.KP, SI_speed, \\\"KP\\\", logger_full)\\n KI = getSpeedDependentConfigParam(\\n config.KI, SI_speed, \\\"KI\\\", logger_full)\\n\\n angle_kp_ki = raw_angle * KP + sum_angles * KI\\n\\n # smoothie -Value == left, Value == right\\n target_angle_sm = angle_kp_ki * -config.A_ONE_DEGREE_IN_SMOOTHIE\\n # target_angle_sm = 0 #Debug COVID_PLACE\\n ad_wheels_pos = smoothie.get_adapter_current_coordinates()[\\\"A\\\"]\\n # sm_wheels_pos = smoothie.get_smoothie_current_coordinates()[\\\"A\\\"]\\n sm_wheels_pos = \\\"off\\\"\\n\\n # compute order angle (smoothie can't turn for huge values immediately also as cancel movement,\\n # so we need to do nav. actions in steps)\\n order_angle_sm = target_angle_sm - ad_wheels_pos\\n\\n # check for out of update frequency and smoothie execution speed range (for nav wheels)\\n if order_angle_sm > config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND * \\\\\\n config.A_ONE_DEGREE_IN_SMOOTHIE:\\n msg = \\\"Order angle changed from \\\" + str(order_angle_sm) + \\\" to \\\" + str(\\n config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND +\\n config.A_ONE_DEGREE_IN_SMOOTHIE) + \\\" due to exceeding degrees per tick allowed range.\\\"\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n order_angle_sm = config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND * \\\\\\n config.A_ONE_DEGREE_IN_SMOOTHIE\\n elif order_angle_sm < -(config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND *\\n config.A_ONE_DEGREE_IN_SMOOTHIE):\\n msg = \\\"Order angle changed from \\\" + str(order_angle_sm) + \\\" to \\\" + str(-(\\n config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND *\\n config.A_ONE_DEGREE_IN_SMOOTHIE)) + \\\" due to exceeding degrees per tick allowed range.\\\"\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n order_angle_sm = -(config.MANEUVERS_FREQUENCY * config.A_DEGREES_PER_SECOND *\\n config.A_ONE_DEGREE_IN_SMOOTHIE)\\n\\n # convert to global smoothie coordinates\\n order_angle_sm += ad_wheels_pos\\n\\n # checking for out of smoothie supported range\\n if order_angle_sm > config.A_MAX:\\n msg = \\\"Global order angle changed from \\\" + str(order_angle_sm) + \\\" to config.A_MAX = \\\" + \\\\\\n str(config.A_MAX) + \\\\\\n \\\" due to exceeding smoothie allowed values range.\\\"\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n order_angle_sm = config.A_MAX\\n elif order_angle_sm < config.A_MIN:\\n msg = \\\"Global order angle changed from \\\" + str(order_angle_sm) + \\\" to config.A_MIN = \\\" + \\\\\\n str(config.A_MIN) + \\\\\\n \\\" due to exceeding smoothie allowed values range.\\\"\\n # print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n order_angle_sm = config.A_MIN\\n\\n # cork x movement during periphery scans control\\n if config.ALLOW_X_MOVEMENT_DURING_SCANS:\\n if x_scan_idx_increasing:\\n x_scan_cur_idx += 1\\n if x_scan_cur_idx >= len(config.X_MOVEMENT_CAMERA_POSITIONS):\\n x_scan_idx_increasing = False\\n x_scan_cur_idx -= 2\\n else:\\n x_scan_cur_idx -= 1\\n if x_scan_cur_idx < 0:\\n x_scan_idx_increasing = True\\n x_scan_cur_idx += 2\\n # TODO do we check SI_speed earlier and do proper calculations and angle validations if here we'll get here a negative order angle instead of positive?\\n response = smoothie.custom_move_to(\\n A_F=config.A_F_MAX,\\n A=order_angle_sm if SI_speed >= 0 else -order_angle_sm,\\n X_F=config.X_MOVEMENT_CAMERA_X_F[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else None,\\n X=config.X_MOVEMENT_CAMERA_POSITIONS[x_scan_cur_idx] if config.ALLOW_X_MOVEMENT_DURING_SCANS else None\\n )\\n\\n if response != smoothie.RESPONSE_OK:\\n msg = \\\"Couldn't turn wheels! Smoothie response:\\\\n\\\" + response\\n print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n else:\\n # TODO opening and closing file too often (likely 4 times per second)\\n # save wheels angle\\n with open(config.LAST_ANGLE_WHEELS_FILE, \\\"w+\\\") as wheels_angle_file:\\n wheels_angle_file.write(\\n str(smoothie.get_adapter_current_coordinates()[\\\"A\\\"]))\\n\\n raw_angle = round(raw_angle, 2)\\n angle_kp_ki = round(angle_kp_ki, 2)\\n order_angle_sm = round(order_angle_sm, 2)\\n sum_angles = round(sum_angles, 2)\\n distance = round(distance, 2)\\n ad_wheels_pos = round(ad_wheels_pos, 2)\\n perpendicular = round(perpendicular, 2)\\n # sm_wheels_pos = round(sm_wheels_pos, 2)\\n gps_quality = cur_pos[2]\\n corridor = \\\"\\\"\\n if current_corridor_side == -1:\\n corridor = \\\"left\\\"\\n elif current_corridor_side == 1:\\n corridor = \\\"right\\\"\\n\\n raw_angle_cruise = round(raw_angle_cruise, 2)\\n\\n msg = str(gps_quality).ljust(5) + \\\\\\n str(raw_angle).ljust(8) + \\\\\\n str(angle_kp_ki).ljust(8) + \\\\\\n str(order_angle_sm).ljust(8) + \\\\\\n str(sum_angles).ljust(8) + \\\\\\n str(distance).ljust(13) + \\\\\\n str(ad_wheels_pos).ljust(8) + \\\\\\n str(sm_wheels_pos).ljust(9) + \\\\\\n point_status.ljust(12) + \\\\\\n str(perpendicular).ljust(10) + \\\\\\n corridor.ljust(9) + \\\\\\n str(centroid_factor).ljust(16) + \\\\\\n str(cruise_factor).ljust(14)\\n print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\\n\\n # TODO vesc sensors are being asked 4 times per second\\n # send voltage and track bumper state\\n vesc_data = vesc_engine.get_sensors_data(\\n report_field_names, vesc_engine.PROPULSION_KEY)\\n if vesc_data is not None and \\\"input_voltage\\\" in vesc_data:\\n if bumper_is_pressed is None:\\n bumper_is_pressed = not vesc_data[\\\"input_voltage\\\"] > config.VESC_BUMBER_UNTRIGGER_VOLTAGE\\n if bumper_is_pressed:\\n msg = f\\\"Bumper is pressed initially before starting moving to point. \\\" \\\\\\n f\\\"({vesc_data['input_voltage']}V)\\\"\\n logger_full.write(msg + \\\"\\\\n\\\")\\n elif not bumper_is_pressed and vesc_data[\\\"input_voltage\\\"] < config.VESC_BUMBER_TRIGGER_VOLTAGE:\\n bumper_is_pressed = True\\n msg = f\\\"Bumper was pressed. ({vesc_data['input_voltage']}V)\\\"\\n logger_full.write(msg + \\\"\\\\n\\\")\\n elif bumper_is_pressed and vesc_data[\\\"input_voltage\\\"] > config.VESC_BUMBER_UNTRIGGER_VOLTAGE:\\n bumper_is_pressed = False\\n msg = f\\\"Bumper was unpressed. ({vesc_data['input_voltage']}V)\\\"\\n logger_full.write(msg + \\\"\\\\n\\\")\\n\\n if config.CONTINUOUS_INFORMATION_SENDING:\\n notification.set_input_voltage(vesc_data[\\\"input_voltage\\\"])\\n\\n prev_pos_obj = cur_pos_obj\\n prev_pos = prev_pos_obj.as_old_list\\n\\n msg = \\\"Nav calc time: \\\" + str(time.time() - nav_start_t)\\n logger_full.write(msg + \\\"\\\\n\\\\n\\\")\\n\\n if config.QUEUE_TRACK_PERFORMANCE:\\n ui_msg_queue_perf[\\\"avg_time\\\"] = ui_msg_queue_perf[\\\"total_time\\\"] / \\\\\\n ui_msg_queue_perf[\\\"total_sends\\\"]\\n msg = f\\\"Position sending performance report: {ui_msg_queue_perf}\\\"\\n if config.VERBOSE:\\n print(msg)\\n logger_full.write(msg + \\\"\\\\n\\\")\",\n \"def search_base_angles(self, motor_positions):\\n\\n # Errore nelle soluzioni\\n err = [0, 0, 0]\\n\\n # Angolo di inizio ricerca\\n # Se gia' eseguita una conversione suo i valori precedenti\\n if self.isLastAnglesValid:\\n self.alpha_start = list(self.alpha)\\n else:\\n # Angolo minimo di partenza ( -alpha_limit )\\n # TO_CHECK: perche' parto da una configurazione sicuramente errata? -10?\\n self.alpha_start = [self.alpha_limit_r, self.alpha_limit_r, self.alpha_limit_r]\\n\\n # Angoli presunti\\n # self.temp = list(self.alpha_start)\\n alpha = list(self.alpha_start)\\n\\n # Altezze reali degli attuatori\\n height = [self.real_height + motor_positions[0],\\n self.real_height + motor_positions[1],\\n self.real_height + motor_positions[2]]\\n\\n # Trovo il mediano tra 0-1-2\\n '''\\n if any([all([motor_positions[0] > motor_positions[1], motor_positions[0] < motor_positions[2]]),\\n all([motor_positions[0] < motor_positions[1], motor_positions[0] > motor_positions[2]])]):\\n is_0_median = True\\n is_1_median = False\\n is_2_median = False\\n else:\\n is_0_median = False\\n if any([all([motor_positions[1] > motor_positions[2], motor_positions[1] < motor_positions[0]]),\\n all([motor_positions[1] < motor_positions[2], motor_positions[1] > motor_positions[0]])]):\\n is_0_median = False\\n is_1_median = True\\n is_2_median = False\\n else:\\n is_1_median = False\\n if any([all([motor_positions[2] > motor_positions[1], motor_positions[2] < motor_positions[0]]),\\n all([motor_positions[2] < motor_positions[1], motor_positions[2] > motor_positions[0]])]):\\n is_0_median = False\\n is_1_median = False\\n is_2_median = True\\n else:\\n is_2_median = False\\n '''\\n\\n # Incrementi degli angoli\\n # TO_CHECK: perche' quattro? L'ultimo e' di backup?\\n step_alpha_base = 0.1 * Kinematic.M_TO_RAD\\n step_alpha = [step_alpha_base, step_alpha_base, step_alpha_base]\\n\\n # Numero di cicli eseguiti\\n self.cycles = 0\\n\\n # Calcolo la condizione iniziale\\n d1 = self.distance_12(alpha, height)\\n err[0] = d1 - self.base_length\\n step_alpha[1] = err[0] * self.ke * step_alpha_base\\n\\n d2 = self.distance_23(alpha, height)\\n err[1] = d2 - self.base_length\\n step_alpha[2] = err[1] * self.ke * step_alpha_base\\n\\n d3 = self.distance_13(alpha, height)\\n err[2] = d3 - self.base_length\\n step_alpha[0] = err[2] * self.ke * step_alpha_base\\n\\n i = 0\\n while i < self.cycle_limit:\\n\\n i += 1\\n\\n # Incremento alfa1 ed azzero alfa2\\n alpha[0] += step_alpha[0]\\n alpha[1] = self.alpha_start[1]\\n\\n j = 0\\n\\n while j < self.cycle_limit:\\n\\n j += 1\\n\\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\\n self.cycles += 1\\n\\n if self.cycles > self.cycle_limit:\\n logging.error(\\\"Maximum number of cycles executed, no solution found!\\\")\\n return False\\n\\n # Incremento alfa1 ed azzero alfa2\\n alpha[1] += step_alpha[1]\\n\\n # Se supero l'angolo limite\\n # Partendo da -10 ( -0.17 ), non devo superare 10 ( 0.17 )\\n if alpha[1] > -self.alpha_limit_r:\\n\\n # Angolo non trovato\\n step_alpha[1] = step_alpha_base\\n step_alpha[0] = err[0] * step_alpha_base * self.ke\\n self.alpha_start[1] = -self.alpha_limit_r - 2 * step_alpha[1]\\n break\\n\\n d1 = self.distance_12(alpha, height)\\n err[0] = d1 - self.base_length\\n step_alpha[1] = err[0] * self.ke * step_alpha_base\\n\\n if abs(err[0]) < self.err_limit:\\n\\n # Trovato il minimo\\n self.alpha_start[1] = alpha[1]\\n step_alpha[1] = step_alpha_base\\n\\n n = 0\\n while n < self.cycle_limit:\\n\\n n += 1\\n\\n # self.next_iteration(alpha, step_alpha, i, j, n, err)\\n self.cycles += 1\\n\\n if self.cycles > self.cycle_limit:\\n logging.error(\\\"Maximum number of cycles executed, no solution found!\\\")\\n return False\\n\\n alpha[2] += step_alpha[2]\\n d2 = self.distance_23(alpha, height)\\n err[1] = d2 - self.base_length\\n step_alpha[2] = err[1] * self.ke * step_alpha_base\\n\\n if abs(err[1]) < self.err_limit:\\n\\n step_alpha[2] = step_alpha_base\\n d3 = self.distance_13(alpha, height)\\n err[2] = d3 - self.base_length\\n step_alpha[0] = err[2] * self.ke * step_alpha_base\\n\\n if abs(err[2]) < self.err_limit:\\n\\n # Trovatas la soluzione\\n self.alpha = list(alpha)\\n return True\\n\\n # NEXT j!!!\\n break\\n\\n # Next i!!!\\n break\",\n \"def indices_and_currents_TSC_2D( charge_electron, positions_x, positions_y, velocity_x, velocity_y,\\\\\\n x_grid, y_grid, ghost_cells, length_domain_x, length_domain_y, dt ):\\n \\n \\n positions_x_new = positions_x + velocity_x * dt\\n positions_y_new = positions_y + velocity_y * dt\\n\\n base_indices_x = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\\n base_indices_y = af.data.constant(0, positions_x.elements(), dtype=af.Dtype.u32)\\n\\n dx = af.sum(x_grid[1] - x_grid[0])\\n dy = af.sum(y_grid[1] - y_grid[0])\\n\\n\\n # Computing S0_x and S0_y\\n ###########################################################################################\\n \\n # Determining the grid cells containing the respective particles\\n \\n x_zone = (((af.abs(positions_x - af.sum(x_grid[0])))/dx).as_type(af.Dtype.u32))\\n y_zone = (((af.abs(positions_y - af.sum(y_grid[0])))/dy).as_type(af.Dtype.u32))\\n\\n \\n # Determing the indices of the closest grid node in x direction\\n\\n temp = af.where(af.abs(positions_x-x_grid[x_zone]) < \\\\\\n af.abs(positions_x-x_grid[x_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_x[temp] = x_zone[temp]\\n\\n temp = af.where(af.abs(positions_x - x_grid[x_zone]) >= \\\\\\n af.abs(positions_x-x_grid[x_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_x[temp] = (x_zone[temp] + 1).as_type(af.Dtype.u32) \\n\\n\\n # Determing the indices of the closest grid node in y direction\\n\\n temp = af.where(af.abs(positions_y-y_grid[y_zone]) < \\\\\\n af.abs(positions_y-y_grid[y_zone + 1])\\\\\\n )\\n\\n if(temp.elements()>0):\\n base_indices_y[temp] = y_zone[temp]\\n\\n temp = af.where(af.abs(positions_y - y_grid[y_zone])>=af.abs(positions_y-x_grid[y_zone + 1]))\\n\\n if(temp.elements()>0):\\n base_indices_y[temp] = (y_zone[temp] + 1).as_type(af.Dtype.u32) \\n\\n # Concatenating the index list for near by grid nodes in x direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n\\n base_indices_minus_two = (base_indices_x - 2).as_type(af.Dtype.u32) \\n base_indices_minus = (base_indices_x - 1).as_type(af.Dtype.u32) \\n base_indices_plus = (base_indices_x + 1).as_type(af.Dtype.u32) \\n base_indices_plus_two = (base_indices_x + 2).as_type(af.Dtype.u32) \\n\\n\\n\\n index_list_x = af.join( 1,\\\\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_x),\\\\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\\\\n )\\n\\n\\n\\n # Concatenating the index list for near by grid nodes in y direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n \\n base_indices_minus_two = (base_indices_y - 2).as_type(af.Dtype.u32) \\n base_indices_minus = (base_indices_y - 1).as_type(af.Dtype.u32) \\n base_indices_plus = (base_indices_y + 1).as_type(af.Dtype.u32) \\n base_indices_plus_two = (base_indices_y + 2).as_type(af.Dtype.u32) \\n\\n\\n index_list_y = af.join( 1,\\\\\\n af.join(1, base_indices_minus_two, base_indices_minus, base_indices_y),\\\\\\n af.join(1, base_indices_plus, base_indices_plus_two),\\\\\\n )\\n\\n # Concatenating the positions_x for determining weights for near by grid nodes in y direction\\n # TSC affect 5 nearest grid nodes around in 1 Dimensions\\n\\n positions_x_5x = af.join( 0,\\\\\\n af.join(0, positions_x, positions_x, positions_x),\\\\\\n af.join(0, positions_x, positions_x),\\\\\\n )\\n\\n positions_y_5x = af.join( 0,\\\\\\n af.join(0, positions_y, positions_y, positions_y),\\\\\\n af.join(0, positions_y, positions_y),\\\\\\n )\\n\\n\\n\\n\\n # Determining S0 for positions at t = n * dt\\n\\n\\n distance_nodes_x = x_grid[af.flat(index_list_x)]\\n\\n distance_nodes_y = y_grid[af.flat(index_list_y)]\\n\\n\\n W_x = 0 * distance_nodes_x.copy()\\n W_y = 0 * distance_nodes_y.copy()\\n\\n\\n # Determining weights in x direction\\n\\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x) < (0.5*dx) )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx)**2\\n\\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x) >= (0.5*dx) )\\\\\\n * (af.abs(distance_nodes_x - positions_x_5x) < (1.5 * dx) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] - positions_x_5x[temp])/dx))**2\\n\\n\\n\\n # Determining weights in y direction\\n\\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x) < (0.5*dy) )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy)**2\\n\\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x) >= (0.5*dy) )\\\\\\n * (af.abs(distance_nodes_y - positions_y_5x) < (1.5 * dy) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] - positions_y_5x[temp])/dy))**2\\n\\n # Restructering W_x and W_y for visualization and ease of understanding\\n\\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\\n W_y = af.data.moddims(W_y, positions_y.elements(), 5)\\n\\n # Tiling the S0_x and S0_y for the 25 indices around the particle\\n \\n S0_x = af.tile(W_x, 1, 1, 5)\\n S0_y = af.tile(W_y, 1, 1, 5)\\n\\n\\n S0_y = af.reorder(S0_y, 0, 2, 1)\\n\\n\\n\\n #Computing S1_x and S1_y\\n ###########################################################################################\\n\\n positions_x_5x_new = af.join( 0,\\\\\\n af.join(0, positions_x_new, positions_x_new, positions_x_new),\\\\\\n af.join(0, positions_x_new, positions_x_new),\\\\\\n )\\n\\n positions_y_5x_new = af.join( 0,\\\\\\n af.join(0, positions_y_new, positions_y_new, positions_y_new),\\\\\\n af.join(0, positions_y_new, positions_y_new),\\\\\\n )\\n\\n\\n\\n\\n # Determining S0 for positions at t = n * dt\\n\\n W_x = 0 * distance_nodes_x.copy()\\n W_y = 0 * distance_nodes_y.copy()\\n\\n\\n # Determining weights in x direction\\n\\n temp = af.where(af.abs(distance_nodes_x - positions_x_5x_new) < (0.5*dx) )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.75 - (af.abs(distance_nodes_x[temp] - positions_x_5x_new[temp])/dx)**2\\n\\n temp = af.where((af.abs(distance_nodes_x - positions_x_5x_new) >= (0.5*dx) )\\\\\\n * (af.abs(distance_nodes_x - positions_x_5x_new) < (1.5 * dx) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_x[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_x[temp] \\\\\\n - positions_x_5x_new[temp])/dx\\\\\\n )\\\\\\n )**2\\n\\n\\n\\n # Determining weights in y direction\\n\\n temp = af.where(af.abs(distance_nodes_y - positions_y_5x_new) < (0.5*dy) )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.75 - (af.abs(distance_nodes_y[temp] \\\\\\n - positions_y_5x_new[temp]\\\\\\n )/dy\\\\\\n )**2\\n\\n temp = af.where((af.abs(distance_nodes_y - positions_y_5x_new) >= (0.5*dy) )\\\\\\n * (af.abs(distance_nodes_y - positions_y_5x_new) < (1.5 * dy) )\\\\\\n )\\n\\n if(temp.elements()>0):\\n W_y[temp] = 0.5 * (1.5 - (af.abs(distance_nodes_y[temp] \\\\\\n - positions_y_5x_new[temp])/dy\\\\\\n )\\\\\\n )**2\\n\\n # Restructering W_x and W_y for visualization and ease of understanding\\n\\n W_x = af.data.moddims(W_x, positions_x.elements(), 5)\\n W_y = af.data.moddims(W_y, positions_x.elements(), 5)\\n\\n # Tiling the S0_x and S0_y for the 25 indices around the particle \\n \\n S1_x = af.tile(W_x, 1, 1, 5)\\n S1_y = af.tile(W_y, 1, 1, 5)\\n\\n S1_y = af.reorder(S1_y, 0, 2, 1)\\n\\n\\n ###########################################################################################\\n\\n # Determining the final weight matrix for currents in 3D matrix form factor\\n\\n\\n W_x = (S1_x - S0_x) * (S0_y + (0.5 *(S1_y - S0_y)) )\\n\\n\\n W_y = (S1_y - S0_y) * (S0_x + (0.5 *(S1_x - S0_x)) )\\n\\n\\n ###########################################################################################\\n\\n\\n # Assigning Jx and Jy according to Esirkepov's scheme\\n\\n Jx = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\\n Jy = af.data.constant(0, positions_x.elements(), 5, 5, dtype = af.Dtype.f64)\\n\\n\\n Jx[:, 0, :] = -1 * charge_electron * (dx/dt) * W_x[:, 0, :].copy()\\n Jx[:, 1, :] = Jx[:, 0, :] + -1 * charge_electron * (dx/dt) * W_x[:, 1, :].copy()\\n Jx[:, 2, :] = Jx[:, 1, :] + -1 * charge_electron * (dx/dt) * W_x[:, 2, :].copy()\\n Jx[:, 3, :] = Jx[:, 2, :] + -1 * charge_electron * (dx/dt) * W_x[:, 3, :].copy()\\n Jx[:, 4, :] = Jx[:, 3, :] + -1 * charge_electron * (dx/dt) * W_x[:, 4, :].copy()\\n \\n # Computing current density using currents\\n \\n Jx = (1/(dx * dy)) * Jx\\n\\n\\n Jy[:, :, 0] = -1 * charge_electron * (dy/dt) * W_y[:, :, 0].copy()\\n Jy[:, :, 1] = Jy[:, :, 0] + -1 * charge_electron * (dy/dt) * W_y[:, :, 1].copy()\\n Jy[:, :, 2] = Jy[:, :, 1] + -1 * charge_electron * (dy/dt) * W_y[:, :, 2].copy()\\n Jy[:, :, 3] = Jy[:, :, 2] + -1 * charge_electron * (dy/dt) * W_y[:, :, 3].copy()\\n Jy[:, :, 4] = Jy[:, :, 3] + -1 * charge_electron * (dy/dt) * W_y[:, :, 4].copy()\\n \\n # Computing current density using currents\\n\\n Jy = (1/(dx * dy)) * Jy\\n\\n # Preparing the final index and current vectors\\n ###########################################################################################\\n \\n \\n # Determining the x indices for charge deposition\\n index_list_x_Jx = af.flat(af.tile(index_list_x, 1, 1, 5))\\n\\n # Determining the y indices for charge deposition\\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\\n index_list_y_Jx = af.flat(af.reorder(y_current_zone, 0, 2, 1))\\n\\n\\n currents_Jx = af.flat(Jx)\\n\\n # Determining the x indices for charge deposition\\n index_list_x_Jy = af.flat(af.tile(index_list_x, 1, 1, 5))\\n\\n # Determining the y indices for charge deposition\\n y_current_zone = af.tile(index_list_y, 1, 1, 5)\\n index_list_y_Jy = af.flat(af.reorder(y_current_zone, 0, 2, 1))\\n \\n # Flattenning the Currents array\\n currents_Jy = af.flat(Jy)\\n\\n af.eval(index_list_x_Jx, index_list_y_Jx)\\n af.eval(index_list_x_Jy, index_list_y_Jy)\\n af.eval(currents_Jx, currents_Jy)\\n\\n\\n return index_list_x_Jx, index_list_y_Jx, currents_Jx,\\\\\\n index_list_x_Jy, index_list_y_Jy, currents_Jy\",\n \"def test_MagmOcGJ1132b():\\n # Remove old log file\\n subprocess.run(['rm', 'GJ1132.log'], cwd=cwd)\\n # Run vplanet\\n subprocess.run(['../../vplanet', 'vpl.in', '-q'], cwd=cwd)\\n\\n # Grab the output\\n output = GetOutput(path=cwd)\\n\\n # Primary Variables: GJ1132b -- checks MagmOc parameters\\n assert np.isclose(output.log.final.GJ1132b.PotTemp, 3358.229436)\\n assert np.isclose(output.log.final.GJ1132b.SurfTemp, 4000.000000)\\n assert np.isclose(output.log.final.GJ1132b.SolidRadius, 0.750604)\\n assert np.isclose(output.log.final.GJ1132b.WaterMassMOAtm, 99.456333)\\n assert np.isclose(output.log.final.GJ1132b.WaterMassSol, 0.174876)\\n assert np.isclose(output.log.final.GJ1132b.OxygenMassMOAtm, 3.946430e+18)\\n assert np.isclose(output.log.final.GJ1132b.OxygenMassSol, 4.449172e+17)\\n assert np.isclose(output.log.final.GJ1132b.HydrogenMassSpace, 5.736131e+19)\\n assert np.isclose(output.log.final.GJ1132b.OxygenMassSpace, 4.508558e+20)\\n assert np.isclose(output.log.final.GJ1132b.CO2MassMOAtm, 1.748940e-296)\\n assert np.isclose(output.log.final.GJ1132b.CO2MassSol, 1.748940e-296)\",\n \"def trap_depth(V,X,Y,Z,Im,Jm,Km): \\n from project_parameters import debug,scale,position\\n #from all_functions import sum_of_e_field,spher_harm_bas,spher_harm_exp,spher_harm_cmp,find_saddle\\n def a(a,N):\\n \\\"\\\"\\\"Shortcut function to convert array x into a row vector.\\\"\\\"\\\" \\n a=np.ravel(a, order='F') # Same order\\n return a\\n N1,N2,N3=V.shape\\n N=N1*N2*N3\\n [Ex,Ey,Ez]=np.gradient(V,abs(X[1]-X[0])/scale,abs(Y[1]-Y[0])/scale,abs(Z[1]-Z[0])/scale)\\n E=np.sqrt(Ex**2+Ey**2+Ez**2)\\n # identify the escape position and height by checking each point\\n minElectricField=np.max(E) # initialize as maximum E field magnitude\\n distance=0\\n escapeHeight=1\\n escapePosition=[0,0,0]\\n [Im,Jm,Km] = find_saddle(V,X,Y,Z,3)\\n Vm = V[Im,Jm,Km]\\n for i in range(N1):\\n for j in range(N2):\\n for k in range(N3):\\n if E[i,j,k]<minElectricField:\\n distance=abs(np.sqrt((Im-i)**2+(Jm-j)**2+(Km-k)**2)) \\n if distance > 6:\\n minElectricField=E[i,j,k]\\n escapeHeight=V[i,j,k]\\n escapePosition=[i,j,k]\\n if debug.trap_depth: \\n print E[i,j,k],V[i,j,k],[i,j,k],distance\\n check=1 \\n if debug.trap_depth: \\n print minElectricField,escapeHeight,escapePosition,distance \\n if distance<check:\\n print('trap_depth.py: Escape point too close to trap minimum. Improve grid resolution or extend grid.')\\n if escapeHeight>0.2:\\n print('trap_depth.py: Escape point parameter too high. Improve grid resolution or extend grid.')\\n D=escapeHeight-Vm\\n [Ie,Je,Ke]=escapePosition\\n [Xe,Ye,Ze]=[X[Ie],Y[Je],Z[Ke]] \\n return [D,Xe,Ye,Ze]\",\n \"def beam_positions(closepack=False):\\n \\n x_pos, y_pos = [], []\\n\\n x=0\\n for j in range(0,6,1):\\n x += 0.1\\n y=0\\n for k in range(0,6,2):\\n y += 0.2\\n x_pos.append(x+(0.05 if closepack else 0))\\n y_pos.append(y)\\n y += 0.2\\n x_pos.append(x)\\n y_pos.append(y)\\n\\n return x_pos, y_pos\",\n \"def field_at(sources, location):\\n vector = polar_to_cart(sources[0].detect(location))\\n for source in sources[1:]:\\n vector = np.add(vector, polar_to_cart(source.detect(location)))\\n return vector\",\n \"def fix_sphere_h (center_x, center_y, center_z, radius, centers, radii, len_points, list_of_a):\\n g_x = []\\n g_y = []\\n g_z = []\\n points = [hydrogen_coord_gen(center_x, center_y, center_z, radius) for i in range(0, len_points)] \\n x = [points[i][0] for i in range(0, len(points))] \\n y = [points[i][1] for i in range(0, len(points))]\\n z = [points[i][2] for i in range(0, len(points))]\\n for i in range(0, len(points)):\\n check = 0\\n check_b = 0\\n j = 0\\n while (j <= (len(centers) - 1) and (check == 0)): \\n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], centers[j][0], centers[j][1], centers[j][2]) < radii[j]):\\n check += 1\\n j += 1\\n h = 0\\n while ((check_b == 0) and (h <= len(list_of_a) -1)):\\n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], list_of_a[h].x, list_of_a[h].y, list_of_a[h].z) <= 1.50): \\n check_b += 1\\n h += 1\\n if ((check == 0) and (check_b == 0)):\\n g_x.append(x[i])\\n g_y.append(y[i])\\n g_z.append(z[i])\\n return g_x, g_y, g_z\",\n \"def bomb_vector(self):\\n\\n\\t\\tif self.b_offset == 0:\\n\\t\\t\\top = sin\\n\\t\\telse:\\n\\t\\t\\top = cos\\n\\n\\t\\tself.y -= self.speed\\n\\t\\tself.rect.y = self.y\\n\\t\\t# MMMMMMMMMMMMMMMMMMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATHS\\n\\t\\tself.x = int((self.g_settings.screen_height/2) + self.amplitude*op(self.frequency*((float(self.y)/self.g_settings.screen_width)*(2*pi) + (self.speed*time()))))\\n\\t\\tif self.b_offset == 0:\\n\\t\\t\\tself.rect.x = self.x + self.position_x - 16\\n\\t\\telif self.b_offset == 1:\\n\\t\\t\\tself.rect.x = self.x + self.position_x + 16\\n\\t\\tself.screen.blit(self.image, self.rect)\",\n \"def approach_gps(g_lat,g_lon,emily_lat_start, emily_lon_start, pose_rad, Parameters): #approach a gps position using potential fields\\r\\n\\tx_goal,y_goal = latlongtoxy(g_lat,g_lon,g_lat)\\r\\n\\tx_e_start,y_e_start = latlongtoxy(emily_lat_start,emily_lon_start,g_lat)\\r\\n\\r\\n\\tprint (\\\"\\\\n HERE I AM\\\\n\\\\n\\\")\\r\\n\\r\\n\\tdist = haver_distance(g_lat, g_lon, emily_lat_start, emily_lon_start)\\r\\n\\tinitial_dist = dist\\r\\n\\r\\n\\tprint ('Distance: ',dist)\\r\\n\\theading = get_heading(emily_lat_start, emily_lon_start, g_lat, g_lon)\\r\\n print ('After get heading')\\r\\n\\t# Eric: I'm not sure if turn_towards is necessary for a successful run.\\r\\n\\t#turn_towards(heading)\\r\\n\\tprint ('After Turn towards')\\r\\n\\t#turn towards the goal initially\\r\\n\\r\\n\\tstart_time = time.time()\\r\\n\\tcurrent_time = 0\\r\\n\\tdstore = []\\r\\n\\thstore = []\\r\\n\\twhile(dist >= goal_radius):\\r\\n\\r\\n\\t\\t#------------ code for reading gps location of emily and its orientation ------\\r\\n\\t\\te_lat = vehicle.location.global_frame.lat\\r\\n\\t\\te_lon = vehicle.location.global_frame.lon\\r\\n\\t\\te_heading = vehicle.heading * pi/180\\t\\t# convert heading to radians\\r\\n\\t\\t#------------------ get e_lat,e_lon, e_orient ---------------------\\r\\n\\r\\n\\r\\n\\t\\tx_e,y_e = latlongtoxy(e_lat,e_lon,g_lat)\\t\\t\\t#change latitude and longitude to xy\\r\\n\\r\\n\\t\\t#x,y are given to approach victim function as y,x to algin the north heading and direction in x,y\\r\\n\\r\\n\\t\\tdx,dy = approach_victim_behaviour(y_goal,x_goal, y_e,x_e, pose_rad, Parameters)\\t#get potential field vector\\r\\n\\t\\trc1, rc3 = dxdytorc(dx,dy, e_heading,g_lon)\\t\\t\\t\\t\\t#get rc parameters\\r\\n\\t\\tdist = haver_distance(g_lat, g_lon, e_lat, e_lon)\\t\\t\\t\\t#haversine distance\\r\\n\\r\\n\\t\\tcurrent_time = time.time() - start_time\\r\\n\\t\\tprint (\\\"Time, Heading, Distance\\\")\\r\\n\\t\\tprint (current_time, e_heading*180/pi, dist)\\r\\n\\t\\tdstore.append(dist)\\r\\n\\t\\thstore.append(e_heading*180/pi)\\r\\n\\t\\t#code for sending the writing the rc commands\\r\\n\\t\\t# 3 is the thrust control\\r\\n\\t\\t#vehicle.channels.overrides = {'3':rc3}\\r\\n\\t\\tsendThrottleCommand(rc3, enableThrottle)\\r\\n\\t\\ttime.sleep(0.5)\\r\\n\\t\\tvehicle.channels.overrides = {'1':rc1}\\r\\n\\t\\tprint (\\\"Rudder: \\\",rc1)\\r\\n\\t\\tprint (\\\"Throttle: \\\",rc3)\\r\\n\\t\\tsaveToLog(e_lat, e_lon,dist,rc1,rc3)\\r\\n\\t\\ttime.sleep(0.5)\\r\\n\\tprint(initial_dist)\\r\\n\\tprint(\\\"intial \\\", emily_lat_start,emily_lon_start)\\r\\n\\tprint(\\\"final \\\",e_lat,e_lon)\\r\\n\\tplt.plot(dstore)\\r\\n\\t#plt.title('Distance form home vs time')\\r\\n\\tplt.xlabel(\\\"Time\\\")\\r\\n\\tplt.ylabel('Distance')\\r\\n\\tplt.show()\\r\\n\\tplt.plot(hstore)\\r\\n\\tplt.show()\",\n \"def preprocess(self):\\n\\n mm_magcoord.add_aacgm_coordinates(self)\\n mm_magcoord.add_quasi_dipole_coordinates(self)\\n mm_sc.calculate_ecef_velocity(self)\\n mm_sc.add_ram_pointing_sc_attitude_vectors(self)\\n\\n return\",\n \"def get_fan_in(xy=(0, 0), dim_x_l=10, dim_y_l=10, dim_x_u=9, dim_y_u=9, block_x=2, block_y=2, radius=2):\\n x = xy[0]\\n y = xy[1]\\n if dim_x_u > 1:\\n factor_x = ((dim_x_l-1)-(block_x-1))/(1.0*(dim_x_u-1))\\n else:\\n factor_x = ((dim_x_l-1)-(block_x))/2.0\\n if dim_y_u > 1:\\n factor_y = ((dim_y_l-1)-(block_y-1))/(1.0*(dim_y_u-1))\\n else:\\n factor_y = ((dim_y_l-1)-(block_y))/2.0\\n results = []\\n if dim_x_u > 1 and dim_y_u > 1:\\n for xx in range(block_x):\\n for yy in range(block_y):\\n if (xx-(block_x-1)*0.5)**2 + (yy-(block_y-1)*0.5)**2 > radius**2:\\n continue\\n results.append((int((factor_x*(x))+xx), int((factor_y*(y))+yy)))\\n return results\\n elif dim_x_u == 1 and dim_y_u > 1:\\n for xx in range(block_x):\\n for yy in range(block_y):\\n if (xx-(block_x-1)*0.5)**2 + (yy-(block_y-1)*0.5)**2 > radius**2:\\n continue\\n results.append((int((dim_x_l-block_x)/2.0+xx), int((factor_y*(y)+yy))))\\n return results\\n elif dim_x_u > 1 and dim_y_u == 1:\\n for xx in range(block_x):\\n for yy in range(block_y):\\n if (xx-(block_x-1)*0.5)**2 + (yy-(block_y-1)*0.5)**2 > radius**2:\\n continue\\n results.append((int((factor_x*(x)+xx)), int((dim_y_l-block_y)/2.0+yy)))\\n return results\\n elif dim_x_u == 1 and dim_y_u == 1:\\n for xx in range(block_x):\\n for yy in range(block_y):\\n if (xx-(block_x-1)*0.5)**2 + (yy-(block_y-1)*0.5)**2 > radius**2:\\n continue\\n results.append((int((dim_x_l-block_x)/2.0+xx), int((dim_y_l-block_y)/2.0+yy)))\\n return results\",\n \"def get_bforce_wm_ws_Gx_surf(self):\\n\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w'] \\n \\n self.Gm1 = np.zeros([Ly])\\n self.dGm1_dS = np.zeros([Ly]) \\n self.Gt1 = np.zeros([Ly])\\n self.dGt1_dS = np.zeros([Ly]) \\n self.Bfsfc_bl = np.zeros([Ly])\\n self.Av_bl = np.zeros([Ly])\\n self.dAv_bl = np.zeros([Ly])\\n \\n #debugging\\n self.wm_surf = np.zeros([Ly])\\n self.ws_surf = np.zeros([Ly]) \\n\\n #---> j-loop\\n for j in range(Ly): \\n k_w = self.kbl[j] # KBL is \\\"new bl index after calling find_new_kbl()\\n z_bl = z_u_w[j,N] - self.hbls[j]\\n zscale = self.hbls[j] \\n \\n if self.swr_frac[j,k_w-1] > 0:\\n Bfsfc = self.Bo[j] + self.Bosol[j] * ( 1. - self.swr_frac[j,k_w-1]\\\\\\n * self.swr_frac[j,k_w] * ( z_u_w[j,k_w] - z_u_w[j,k_w-1] )\\\\\\n / (self.swr_frac[j,k_w] * (z_u_w[j,k_w] - z_bl)\\\\\\n + self.swr_frac[j,k_w-1] * (z_bl - z_u_w[j,k_w-1]) ))\\n \\n else:\\n Bfsfc = self.Bo[j] + self.Bosol[j]\\n \\n # CALCUALTE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm_surf[j] = wm\\n self.ws_surf[j] = ws \\n\\n if self.LIMIT_UNSTABLE_ONLY:\\n f1 = 5. * np.max([0,Bfsfc]) * self.vonKar / (self.ustar[j]**4+self.eps)\\n else:\\n f1 = 0\\n\\n \\n cff = 1. / (z_u_w[j,k_w] - z_u_w[j,k_w-1])\\n cff_up = cff * (z_bl - z_u_w[j,k_w])\\n cff_dn = cff * (z_u_w[j,k_w] - z_bl)\\n\\n #MOMENTUM \\n Av_bl = cff_up * self.Kv_old[j,k_w] + cff_dn * self.Kv_old[j,k_w-1]\\n dAv_bl = cff * (self.Kv_old[j,k_w] - self.Kv_old[j,k_w-1])\\n self.Av_bl[j] = Av_bl\\n self.dAv_bl[j] = dAv_bl\\n self.Gm1[j] = Av_bl / (self.hbls[j] * wm + self.eps)\\n self.dGm1_dS[j] = np.min([0.,Av_bl*f1-dAv_bl/(wm+self.eps)]) \\n\\n #TEMPERATURE(BUOYANCY)\\n At_bl = cff_up * self.Kt_old[j,k_w] + cff_dn * self.Kt_old[j,k_w-1]\\n dAt_bl = cff * (self.Kt_old[j,k_w] - self.Kt_old[j,k_w-1])\\n self.Gt1[j] = At_bl / (self.hbls[j] * ws + self.eps)\\n self.dGt1_dS[j] = np.min([0.,At_bl*f1-dAt_bl/(ws+self.eps)]) \\n\\n self.Bfsfc_bl[j] = Bfsfc\",\n \"def getMagneticField(self, z):\\n return float(self.solenoid.B_interp(z))\",\n \"def get_observations(self):\\n joint_states = self.joints_state\\n self.force = self.wrench_stamped.wrench.force\\n self.torque = self.wrench_stamped.wrench.torque\\n self.static_taxel = self.tactile_static.taxels\\n# dynamic_taxel= tactile_dynamic\\n\\n# print(\\\"[force]\\\", self.force.x, self.force.y, self.force.z)\\n# print(\\\"[torque]\\\", self.torque.x, self.torque.y, self.torque.z)\\n shp_joint_ang = joint_states.position[0]\\n shl_joint_ang = joint_states.position[1]\\n elb_joint_ang = joint_states.position[2]\\n wr1_joint_ang = joint_states.position[3]\\n wr2_joint_ang = joint_states.position[4]\\n wr3_joint_ang = joint_states.position[5]\\n\\n shp_joint_vel = joint_states.velocity[0]\\n shl_joint_vel = joint_states.velocity[1]\\n elb_joint_vel = joint_states.velocity[2]\\n wr1_joint_vel = joint_states.velocity[3]\\n wr2_joint_vel = joint_states.velocity[4]\\n wr3_joint_vel = joint_states.velocity[5]\\n\\n q = [shp_joint_ang, shl_joint_ang, elb_joint_ang, wr1_joint_ang, wr2_joint_ang, wr3_joint_ang]\\n# print(\\\"q(observation):\\\", q)\\n eef_x, eef_y, eef_z = self.get_xyz(q)\\n self.end_effector = self.get_xyz(q)\\n eef_x_ini, eef_y_ini, eef_z_ini = self.get_xyz(self.init_joint_pose2) \\n\\n delta_image_r, delta_image_l = self.get_image()\\n self.cnn_image_r = agent.update_cnn(delta_image_r)\\n self.cnn_image_l = agent.update_cnn(delta_image_l)\\n self.cnn_image_r_list = self.cnn_image_r.tolist()\\n self.cnn_image_l_list = self.cnn_image_l.tolist()\\n print(\\\"r_list\\\", self.cnn_image_r_list)\\n print(\\\"l_list\\\", self.cnn_image_l_list)\\n\\n observation = []\\n# rospy.logdebug(\\\"List of Observations==>\\\"+str(self.observations))\\n for obs_name in self.observations:\\n if obs_name == \\\"shp_joint_ang\\\":\\n observation.append((shp_joint_ang - self.init_joint_pose2[0]) * self.joint_n)\\n elif obs_name == \\\"shl_joint_ang\\\":\\n observation.append((shl_joint_ang - self.init_joint_pose2[1]) * self.joint_n)\\n elif obs_name == \\\"elb_joint_ang\\\":\\n observation.append((elb_joint_ang - self.init_joint_pose2[2]) * self.joint_n)\\n elif obs_name == \\\"wr1_joint_ang\\\":\\n observation.append((wr1_joint_ang - self.init_joint_pose2[3]) * self.joint_n)\\n elif obs_name == \\\"wr2_joint_ang\\\":\\n observation.append((wr2_joint_ang - self.init_joint_pose2[4]) * self.joint_n)\\n elif obs_name == \\\"wr3_joint_ang\\\":\\n observation.append((wr3_joint_ang - self.init_joint_pose2[5]) * self.joint_n)\\n elif obs_name == \\\"shp_joint_vel\\\":\\n observation.append(shp_joint_vel)\\n elif obs_name == \\\"shl_joint_vel\\\":\\n observation.append(shl_joint_vel)\\n elif obs_name == \\\"elb_joint_vel\\\":\\n observation.append(elb_joint_vel)\\n elif obs_name == \\\"wr1_joint_vel\\\":\\n observation.append(wr1_joint_vel)\\n elif obs_name == \\\"wr2_joint_vel\\\":\\n observation.append(wr2_joint_vel)\\n elif obs_name == \\\"wr3_joint_vel\\\":\\n observation.append(wr3_joint_vel)\\n elif obs_name == \\\"eef_x\\\":\\n observation.append((eef_x - eef_x_ini) * self.eef_n)\\n elif obs_name == \\\"eef_y\\\":\\n observation.append((eef_y - eef_y_ini) * self.eef_n)\\n elif obs_name == \\\"eef_z\\\":\\n observation.append((eef_z - eef_z_ini) * self.eef_n)\\n elif obs_name == \\\"force_x\\\":\\n observation.append((self.force.x - self.force_ini.x) / self.force_limit1 * self.force_n)\\n elif obs_name == \\\"force_y\\\":\\n observation.append((self.force.y - self.force_ini.y) / self.force_limit1 * self.force_n)\\n elif obs_name == \\\"force_z\\\":\\n observation.append((self.force.z - self.force_ini.z) / self.force_limit1 * self.force_n)\\n elif obs_name == \\\"torque_x\\\":\\n observation.append((self.torque.x - self.torque_ini.x) / self.torque_limit1 * self.torque_n)\\n elif obs_name == \\\"torque_y\\\":\\n observation.append((self.torque.y - self.torque_ini.y) / self.torque_limit1 * self.torque_n)\\n elif obs_name == \\\"torque_z\\\":\\n observation.append((self.torque.z - self.torque_ini.z) / self.torque_limit1 * self.torque_n)\\n elif obs_name == \\\"image_cnn\\\":\\n for x in range(0, 10):\\n observation.append(self.cnn_image_r_list[0][x])\\n# print(\\\"r_list\\\", self.cnn_image_r_list[0][x])\\n for x in range(0, 10):\\n observation.append(self.cnn_image_l_list[0][x])\\n# print(\\\"l_list\\\", self.cnn_image_l_list[0][x])\\n elif obs_name == \\\"static_taxel\\\":\\n for x in range(0, 28):\\n observation.append((self.static_taxel[0].values[x] - self.static_taxel_ini[0].values[x]) * self.taxel_n)\\n for x in range(0, 28):\\n observation.append((self.static_taxel[1].values[x] - self.static_taxel_ini[1].values[x]) * self.taxel_n)\\n# elif obs_name == \\\"dynamic_taxel\\\":\\n# observation.append(dynamic_taxel[0].values) * self.taxel_n\\n# observation.append(dynamic_taxel[1].values) * self.taxel_n\\n else:\\n raise NameError('Observation Asked does not exist=='+str(obs_name))\\n\\n print(\\\"observation\\\", list(map(round, observation, [3]*len(observation))))\\n# print(\\\"observation\\\", observation)\\n\\n return observation\",\n \"def compute_magnetic_field(self, coords, params=None, basis=\\\"rpz\\\"):\\n if params is None:\\n params = [None] * len(self._fields)\\n if isinstance(params, dict):\\n params = [params]\\n B = 0\\n for i, field in enumerate(self._fields):\\n B += field.compute_magnetic_field(coords, params[i % len(params)], basis)\\n return B\",\n \"def fglidingHST_exact(xy, v, NL, KL, BM, Mm, params):\\n I1 = params['I1']\\n I3 = params['I3']\\n l = params['l']\\n g = params['g']\\n k = params['k']\\n\\n try:\\n NP, NN = np.shape(NL)\\n except:\\n '''There is only one particle'''\\n NP = 1\\n NN = 0\\n\\n # print 'xy = ', xy\\n # print 'v = ', v\\n\\n x = xy[:, 0].ravel() # .reshape(NP,1);\\n y = xy[:, 1].ravel() # .reshape(NP,1);\\n theta = xy[:, 2].ravel() # .reshape(NP,1);\\n phi = xy[:, 3].ravel() # .reshape(NP,1);\\n psi = xy[:, 4].ravel() # .reshape(NP,1);\\n vx = v[:, 0].ravel() # .reshape(NP,1);\\n vy = v[:, 1].ravel() # .reshape(NP,1);\\n vtheta = v[:, 2].ravel() # .reshape(NP,1);\\n vphi = v[:, 3].ravel() # .reshape(NP,1);\\n vpsi = v[:, 4].ravel() # .reshape(NP,1)\\n\\n # if theta is very nearly pi, push it back\\n close_pi = 3.1415\\n # xout[xy[:,2] > close_pi,2] = close_pi\\n theta[theta > close_pi] = close_pi\\n\\n # w3 = vpsi + vphi*np.cos(theta)\\n w3 = params['w3']\\n # if not isinstance(w3,np.ndarray):\\n # print 'w3 --> ndarray'\\n # w3 = np.array(w3)\\n\\n # SPRING FORCE\\n vecx = np.array([[KL[i, j] * (xy[i, 0] - xy[NL[i, j], 0]) for j in range(NN)] for i in range(NP)])\\n vecy = np.array([[KL[i, j] * (xy[i, 1] - xy[NL[i, j], 1]) for j in range(NN)] for i in range(NP)])\\n mag = np.sqrt(vecx ** 2 + vecy ** 2)\\n # KLnoz = KL.copy() #no zeros\\n # KLnoz[KLnoz ==0] = 1. #same value as mag[mag==0], so that stretch=0 for those\\n stretch = mag - BM\\n mag[mag == 0.] = 1. # avoid divide by zero error\\n # print(stretch)\\n springx = k * np.sum(stretch * vecx / mag, axis=-1)\\n springy = k * np.sum(stretch * vecy / mag, axis=-1)\\n # print 'stretch = ', stretch\\n\\n # add them up\\n FX = - springx.ravel() # .reshape(NP,1)\\n FY = - springy.ravel() # .reshape(NP,1)\\n\\n # Set force on fixed particles to zero\\n if 'BIND' in params:\\n if len(params['BIND']) > 0:\\n FX[params['BIND']] = 0.\\n FY[params['BIND']] = 0.\\n\\n # Transform into A frame\\n Fx = FX * np.cos(phi) + FY * np.sin(phi)\\n Fy = -FX * np.sin(phi) + FY * np.cos(phi)\\n\\n # print '\\\\n Fx =', Fx\\n\\n # VERTICAL REACTION FORCE\\n # print 'T1 = ', Mm*g*I1\\n # print 'T2 =', - Mm*l*(I1*np.cos(theta)*(vtheta**2 + vphi**2*np.sin(theta)**2))\\n # print 'T3a = ', I3*w3\\n # print 'T3b = ', vphi*np.sin(theta)**2\\n # print 'T3 = ', I3*w3*vphi*np.sin(theta)**2\\n # print 'T4 = ', - l* np.sin(theta)*np.cos(theta)*Fx\\n # print 'denom = ', I1 + Mm*l**2*np.sin(theta)**2\\n gn = (Mm * g * I1 - Mm * l * (I1 * np.cos(theta) * (vtheta ** 2 + vphi ** 2 * np.sin(theta) ** 2) - \\\\\\n I3 * w3 * vphi * (np.sin(theta) ** 2) - l * np.sin(theta) * np.cos(theta) * Fx)) / (\\n I1 + Mm * l ** 2 * np.sin(theta) ** 2)\\n\\n # print 'gn_ term 1 = ', Mm*g*I1\\n # print 'gn_ denominator = ', (I1 + Mm*l**2*np.sin(theta)**2)\\n # print 'gn_ denom term 2 = ', Mm*l**2\\n print 'gn_exact = ', gn\\n # print 'gn = ', gn\\n\\n # EULER EQUATIONS\\n # print 'denominator = ',I1*np.sin(theta)\\n dvphi = (I3 * w3 * vtheta - 2 * I1 * vphi * vtheta * np.cos(theta) - l * Fy) / (I1 * np.sin(theta))\\n # print 'dvtheta -- term 1:', l*gn[4]*np.sin(theta[4])\\n # print 'dvtheta -- term 2:', -l*Fx[4]*np.cos(theta[4])\\n # print 'dvtheta -- term 3:', I1*vphi[4]**2*np.sin(theta[4])*np.cos(theta[4])\\n # print 'dvtheta -- term 4:', I3*w3[4]*vphi[4]*np.sin(theta[4])\\n dvtheta = (1. / I1) * (l * gn * np.sin(theta) - l * Fx * np.cos(theta) + I1 * vphi ** 2 * np.sin(theta) * np.cos(\\n theta) - I3 * w3 * vphi * np.sin(theta))\\n dvpsi = - dvphi * np.cos(theta) + vphi * np.sin(theta) * vtheta\\n\\n # print 'shape(dvphi)=', np.shape(dvphi)\\n # print 'shape(Fx)=', np.shape(Fx)\\n\\n # SPRING EQUATIONS\\n # print 'dvtheta =', dvtheta\\n wx = l * (dvtheta * np.cos(theta) - vtheta ** 2 * np.sin(theta) - vphi ** 2 * np.sin(theta))\\n wy = l * (dvphi * np.sin(theta) + 2 * vphi * vtheta * np.cos(theta))\\n wX = wx * np.cos(phi) - wy * np.sin(phi)\\n wY = wx * np.sin(phi) + wy * np.cos(phi)\\n dvX = (FX / Mm) - wX\\n dvY = (FY / Mm) - wY\\n\\n # print 'shapes = ', np.shape(dvX), np.shape(dvY),np.shape(dvtheta),np.shape(dvphi),np.shape(dvpsi)\\n ftx = np.dstack((dvX, dvY, dvtheta, dvphi, dvpsi))[0]\\n # print 'Resulting second derivative: ', ftx[1,:]\\n\\n if 'BIND' in params:\\n if len(params['BIND']) > 0:\\n ftx[params['BIND'], 0:2] = [0., 0.]\\n # ftx[params['BIND']] = [0.,0.,0.,0.,0.]\\n\\n # print 'ftx = ', ftx[4,:]\\n # gn_check = Mm*g - Mm*l*(dvtheta*np.sin(theta) + vtheta**2*np.cos(theta))\\n # print 'gn_check = ', gn_check-gn\\n # if sum(abs(gn_check -gn)) > 1e-8:\\n # print 'gn vertical reaction force does not match up!'\\n # print 'gn_check - gn = ', gn_check-gn\\n print 'ftx = ', ftx\\n\\n return ftx\",\n \"def sunpos_mag(t,lat,lon,elev,gm,temp=None,press=None,radians=True):\\n #az_zen is a (...,5) dimension ndarray\\n az_zen = sunpos(t,lat,lon,elev,temp,press,radians=radians)\\n decl = declination(lat,lon,elev,t,gm,radians)\\n az_zen[...,0] -= decl\\n #subtract declination to go from true N to magnetic N\\n return az_zen\",\n \"def fix_sphere_m (center_x, center_y, center_z, radius, centers, radii, len_points):\\n \\n g_x = []\\n g_y = []\\n g_z = []\\n points = [hydrogen_coord_gen(center_x, center_y, center_z, radius) for i in range(0, len_points)] \\n x = [points[i][0] for i in range(0, len(points))] \\n y = [points[i][1] for i in range(0, len(points))]\\n z = [points[i][2] for i in range(0, len(points))]\\n\\n for i in range(0, len(points)):\\n check = 0\\n j = 0\\n while (j <= (len(centers) - 1) and (check == 0)): \\n if (calculate_3D_distance_2_centers(x[i], y[i], z[i], centers[j][0], centers[j][1], centers[j][2]) < radii[j]):\\n check += 1\\n j += 1\\n if (check == 0):\\n g_x.append(x[i])\\n g_y.append(y[i])\\n g_z.append(z[i])\\n\\n return g_x, g_y, g_z\",\n \"def photons(self, depth=1):\\n self.dx[:,:self.W-1] = self.z[:,1:] - self.z[:,:self.W-1]\\n self.dy[:self.H-1,:] = self.z[1:,:] - self.z[:self.H-1,:]\\n px = self.xv - self.dx*depth\\n py = self.yv - self.dy*depth\\n return px,py\",\n \"def get_floor_reference_points():\\n global Z # This declaration is needed to modify the global variable Z\\n global floor_reference_points # Maybe erase.\\n global floor_reference_orientations # Maybe erase.\\n \\n #Z = (-0.04311285564353425 -0.04512672573083166 -0.04080078888404003 -0.046071914959185875)/4\\n #Z= -0.04721129960500225\\n Z = -0.15113003072395247\\n print(Z)\\n# [0.5264201148167275, 0.40034933311487086, -0.027560670871152958]\\n# Point 1 = [0.5264201148167275, 0.40034933311487086, -0.027560670871152958]\\n# Move the LEFT arm to point 2 and press enter.\\n# Move the LEFT arm to point 3 and press enter.\\n# Point 3 = [0.8164126163781988, 0.00011724257622775782, -0.006060458646583389]\\n# Move the LEFT arm to point 4 and press enter.\\n# Point 4 = [0.5774338486223564, -0.02912627450728407, -0.02923769860966796]\\n# Point 1 = [0.45835412247904794, 0.4167330917312844, -0.11362745036843477]\\n# Move the LEFT arm to point 2 and press enter.\\n# Point 2 = [0.7046556740624649, 0.45390428836232344, -0.11322759071560898]\\n# Move the LEFT arm to point 3 and press enter.\\n# Point 3 = [0.7778487250094798, 0.07406413897305184, -0.11181591166991744]\\n# Move the LEFT arm to point 4 and press enter.\\n# Point 4 = [0.5418466718761972, 0.034360381218309734, -0.11464607923115094]\\n\\n #return [[p1[0],p1[1]], [p2[0],p2[1]], [p3[0],p3[1]], [p4[0],p4[1]]]\\n \\n #print p4\\n filename = \\\"/home/sampath/midca/examples/_gazebo_baxter/calibration.txt\\\"\\n f = open(filename, 'r')\\n p1 = f.readline().split(' ')\\n p2 = f.readline().split(' ')\\n p3 = f.readline().split(' ')\\n p4 = f.readline().split(' ')\\n \\n p1[0] = float(p1[0])\\n p1[1] = float(p1[1])\\n p2[0] = float(p2[0])\\n p2[1] = float(p2[1])\\n p3[0] = float(p3[0])\\n p3[1] = float(p3[1])\\n p4[0] = float(p4[0])\\n p4[1] = float(p4[1])\\n \\n return [[p1[0], p1[1]],\\n [p2[0], p2[1]],\\n [p3[0], p3[1]],\\n [p4[0], p4[1]]]\",\n \"def main():\\r\\n #Drag Force Equation: 1/2 * rho * Cd * A * v^2\\r\\n\\r\\n #User-Defined Constants\\r\\n global m\\r\\n global v0\\r\\n global theta\\r\\n global rho #Fluid Density\\r\\n global A #Cross-sectional Area\\r\\n global Cd #Drag coefficient\\r\\n global tStep\\r\\n global g\\r\\n\\r\\n m = 1\\r\\n v0 = 30\\r\\n theta = math.radians(45)\\r\\n rho = 1.225\\r\\n A = 0.05\\r\\n Cd = 0.5 #A ball is approx. 0.5\\r\\n tStep = 0.005\\r\\n g = 9.8\\r\\n\\r\\n\\r\\n #Data Structures\\r\\n global tHist\\r\\n global xHist\\r\\n global yHist\\r\\n global thetaHist\\r\\n global vHist\\r\\n global vXHist\\r\\n global vYHist\\r\\n tHist = [] #list for all time steps\\r\\n xHist = [] #list for all x position steps\\r\\n yHist = [] #list for all y position steps\\r\\n thetaHist = [] #List for all theta at every time step\\r\\n vHist = [] #list for all velocities at every time step\\r\\n vXHist = [] #list for all x-axis velocities at every time step\\r\\n vYHist = [] #list for all y-axis velocities at every time step\\r\\n\\r\\n #Initialize intial values\\r\\n tHist.append(0.0)\\r\\n xHist.append(0.0)\\r\\n yHist.append(0.0)\\r\\n thetaHist.append(theta)\\r\\n vHist.append(v0)\\r\\n vXHist.append(v0 * math.cos(theta))\\r\\n vYHist.append(v0 * math.sin(theta))\\r\\n vTheta = math.atan(vYHist[0] / vXHist[0])\\r\\n # print(\\\"t: \\\" + str(tHist[0]))\\r\\n # print(\\\"x: \\\" + str(xHist[0]))\\r\\n # print(\\\"y: \\\" + str(yHist[0]))\\r\\n # print(\\\"v: \\\" + str(vHist[0]))\\r\\n # print(\\\"Vx: \\\" + str(vXHist[0]))\\r\\n # print(\\\"Vy: \\\" + str(vYHist[0]))\\r\\n\\r\\n #Convenience variables\\r\\n global k\\r\\n\\r\\n counter = 1\\r\\n #Loop until the y-displacement becomes negative (projectile reaches ground again)\\r\\n while True:\\r\\n tHist.append(counter * tStep) #increment time\\r\\n print(\\\"t: \\\" + str(tHist[counter]))\\r\\n\\r\\n #This large hunk is the solution to the net force differential equation in the x-axis\\r\\n # oneOverVX = (1/vXHist[counter-1]) + (((rho*A*Cd*math.cos(thetaHist[counter-1]))/(2*m))*(tStep)) #STABLE\\r\\n # oneOverVX = (1/vXHist[counter-1]) + (((rho*A*Cd)/(2*m))*(tStep))\\r\\n # oneOverVX = (1/vHist[counter-1]) + (((rho*A*Cd*math.cos(thetaHist[counter-1]))/(2*m))*(tStep))\\r\\n oneOverVX = (1/vXHist[counter-1]) + ((rho*A*Cd)/(2*m*math.cos(thetaHist[counter-1]))*(tStep)) #This is one over the solution for velocity in the x-axis net force differential equation\\r\\n vXHist.append(1 / oneOverVX) #Adding the velocity to the list of velocities\\r\\n\\r\\n vY0 = vYHist[counter-1] #Convenience variable\\r\\n # k = 0.5 * rho * A * Cd * math.sin(abs(thetaHist[counter-1])) #STABLE\\r\\n # k = 0.5 * rho * A * Cd\\r\\n k = (rho * A * Cd) / (2 * math.sin(abs(thetaHist[counter-1]))) #Convenience variable\\r\\n print(\\\"k: \\\" + str(k))\\r\\n print(\\\"vX: \\\" + str(vXHist[counter]))\\r\\n rootGMK = math.sqrt(g*m*k) #Convenience variable\\r\\n if vYHist[counter-1] > 0.0: #If the projectile is going upwards\\r\\n #Solving the y-axis differential equation for velocity\\r\\n equationRight = -rootGMK * ((tStep/m) - (math.atan((k*vY0)/(rootGMK))/rootGMK))\\r\\n vYHist.append((math.tan(equationRight) * rootGMK) / k)\\r\\n elif vYHist[counter-1] < 0.0: #If the projectile is going downwards\\r\\n #Solving the y-axis differential equation for velocity\\r\\n\\r\\n # Hand-solved integral\\r\\n # exponent = -(2*tStep*rootGMK)/m\\r\\n # numerator = g*m*math.exp(exponent) - math.exp(exponent)*vY0*rootGMK - vY0*rootGMK - g*m\\r\\n # denominator = math.exp(exponent)*(vY0-rootGMK) - vY0*k - rootGMK\\r\\n # vYHist.append(numerator / denominator)\\r\\n\\r\\n #Wolfram Alpha arctanh integral\\r\\n arctanh =(vY0*math.sqrt(k))/(math.sqrt(g*m))\\r\\n print(\\\"arctanh: \\\" + str(arctanh))\\r\\n equationRight = (np.arctanh(arctanh))/(rootGMK) - (tStep/m)\\r\\n vYHist.append(np.tanh(rootGMK * equationRight) * ((math.sqrt(g*m))/(math.sqrt(k))))\\r\\n else: #If current y velocity is 0\\r\\n vYHist.append(vY0 - g*tStep)\\r\\n print(\\\"vY: \\\" + str(vYHist[counter]))\\r\\n\\r\\n vHist.append(math.hypot(vXHist[counter], vYHist[counter])) #Calculate the net velocity and add it to the velocities list\\r\\n print(\\\"v: \\\" + str(vHist[counter]))\\r\\n thetaHist.append(math.atan(vYHist[counter]/vXHist[counter])) #Calculate the current angle based on the velocities and add it to the theta list\\r\\n print(\\\"0: \\\" + str(math.degrees(thetaHist[counter])))\\r\\n\\r\\n x0 = xHist[counter-1]\\r\\n y0 = yHist[counter-1]\\r\\n\\r\\n # yIntegral = trigintegrate()\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Note: What I wanted to do here was to integrate the velocity functions over the time interval to find the exact\\r\\n changes in position. Unfortunately, I was running short of time and decided it was not worth it to move forward with\\r\\n this final step, and instead worked on the presentation and testing different cases.\\r\\n \\\"\\\"\\\"\\r\\n xHist.append(x0 + vXHist[counter]*tStep) #Calculate new x position using x = x0 + vt\\r\\n yHist.append(y0 + vYHist[counter]*tStep) #Calculate new y position using y = y0 + vt\\r\\n print(\\\"x: \\\" + str(xHist[counter]))\\r\\n print(\\\"y: \\\" + str(yHist[counter]))\\r\\n print()\\r\\n\\r\\n # xHist.append(xHist[counter-1] + vXHist[counter-1]*tStep + 0.5*aXHist[counter-1]*tStep**2)\\r\\n # yHist.append(yHist[counter-1] + vYHist[counter-1]*tStep + 0.5*aYHist[counter-1]*tStep**2)\\r\\n # vXHist.append(vXHist[counter-1] + aXHist[counter-1]*tStep)\\r\\n # vYHist.append(vYHist[counter-1] + aYHist[counter-1]*tStep)\\r\\n # vHist.append(math.hypot(vXHist[counter], vYHist[counter]))\\r\\n #\\r\\n # vTheta = math.atan(vYHist[counter] / vXHist[counter])\\r\\n # xDragAccel = -0.5*rho*Cd*A*vHist[counter]**2*math.cos(vTheta) / m\\r\\n # yDragAccel = -math.copysign(0.5*rho*Cd*A*vHist[counter]**2*math.sin(vTheta) / m, vYHist[counter])\\r\\n #\\r\\n # aXHist.append(xDragAccel)\\r\\n # aYHist.append(-g*tStep + yDragAccel)\\r\\n\\r\\n if vYHist[counter-1] > 0.0 and vYHist[counter] < 0.0: #Check if the projectile has reached it's peak by checking for a critical point\\r\\n print(\\\"max height reached at time=\\\" + str(tHist[counter]))\\r\\n # break\\r\\n\\r\\n # print(\\\"t: \\\" + str(tHist[counter]))\\r\\n # print(\\\"x: \\\" + str(xHist[counter]))\\r\\n # print(\\\"y: \\\" + str(yHist[counter]))\\r\\n # print(\\\"Vx: \\\" + str(vXHist[counter]))\\r\\n # print(\\\"Vy: \\\" + str(vYHist[counter]))\\r\\n # print(\\\"Ax: \\\" + str(aXHist[counter]))\\r\\n # print(\\\"Ay: \\\" + str(aYHist[counter]))\\r\\n\\r\\n if yHist[counter] < 0 or counter > 99999: #End the loop if the projectile has reached the ground (or limit the number of iterations to avoid computer death)\\r\\n break\\r\\n\\r\\n counter += 1\\r\\n\\r\\n plotData()\",\n \"def Sphere_ExactSerendipityLagrangeQuad():\\n\\n mesh = Sphere_CubeToSerendipityLagrangeQuad(1)\\n \\n ################\\n # Modifications for exact sphere\\n ################\\n # x=+1 side\\n def posXvals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.ones(xi1.shape);yb=np.array(-xi1);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n return np.vstack([x,y,z])\\n def posXnormals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.ones(xi1.shape);yb=np.array(-xi1);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = -1.0 * xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\\n dxdxi2 = 1.0 * xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\\n dydxi1 = -1.0 * np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n dydxi2 = 1.0 * yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\\n dzdxi1 = -1.0 * zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\\n dzdxi2 = 1.0 * np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n magnitude = np.sqrt(np.sum(J**2,axis=1))\\n return J.T/magnitude\\n def posXJ(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.ones(xi1.shape);yb=np.array(-xi1);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = -1.0 * xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\\n dxdxi2 = 1.0 * xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\\n dydxi1 = -1.0 * np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n dydxi2 = 1.0 * yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\\n dzdxi1 = -1.0 * zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\\n dzdxi2 = 1.0 * np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n return np.sqrt(np.sum(J**2,axis=1))\\n mesh.eList[0].vals = posXvals\\n mesh.eList[0].normals = posXnormals\\n mesh.eList[0].J = posXJ\\n \\n def posYvals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1);yb=np.ones(xi1.shape);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n return np.vstack([x,y,z])\\n def posYnormals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1);yb=np.ones(xi1.shape);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\\n dydxi2 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n magnitude = np.sqrt(np.sum(J**2,axis=1))\\n return J.T/magnitude\\n def posYJ(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1);yb=np.ones(xi1.shape);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\\n dydxi2 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n return np.sqrt(np.sum(J**2,axis=1))\\n mesh.eList[1].vals = posYvals\\n mesh.eList[1].normals = posYnormals\\n mesh.eList[1].J = posYJ\\n \\n # x=-1 side\\n def negXvals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=-np.ones(xi1.shape);yb=np.array(xi1);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n return np.vstack([x,y,z])\\n def negXnormals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=-np.ones(xi1.shape);yb=np.array(xi1);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\\n dydxi1 = 1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n dydxi2 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n magnitude = np.sqrt(np.sum(J**2,axis=1))\\n return J.T/magnitude\\n def negXJ(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=-np.ones(xi1.shape);yb=np.array(xi1);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-zb+2.0*yy*zb/3.0)\\n dydxi1 = 1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n dydxi2 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-zb+2.0*xx*zb/3.0)\\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n return np.sqrt(np.sum(J**2,axis=1))\\n mesh.eList[2].vals = negXvals\\n mesh.eList[2].normals = negXnormals\\n mesh.eList[2].J = negXJ\\n\\n # y=-1 side\\n def negYvals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(-xi1);yb=-np.ones(xi1.shape);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n return np.vstack([x,y,z])\\n def negYnormals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(-xi1);yb=-np.ones(xi1.shape);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2; \\n dxdxi1 = -1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n dxdxi2 = 1.0*0.5*xb*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5*(-zb+2.0*yy*zb/3.0)\\n dydxi1 = -1.0*0.5*yb*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5*(-xb+2.0*xb*zz/3.0)\\n dydxi2 = 1.0*0.5*yb*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5*(-zb+2.0*xx*zb/3.0)\\n dzdxi1 = -1.0*0.5*zb*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5*(-xb+2.0*xb*yy/3.0)\\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0) \\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n magnitude = np.sqrt(np.sum(J**2,axis=1))\\n return J.T/magnitude\\n def negYJ(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(-xi1);yb=-np.ones(xi1.shape);zb=np.array(xi2);\\n xx=xb**2;yy=yb**2;zz=zb**2; \\n dxdxi1 = -1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n dxdxi2 = 1.0*0.5*xb*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5*(-zb+2.0*yy*zb/3.0)\\n dydxi1 = -1.0*0.5*yb*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5*(-xb+2.0*xb*zz/3.0)\\n dydxi2 = 1.0*0.5*yb*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5*(-zb+2.0*xx*zb/3.0)\\n dzdxi1 = -1.0*0.5*zb*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5*(-xb+2.0*xb*yy/3.0)\\n dzdxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0) \\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n return np.sqrt(np.sum(J**2,axis=1))\\n mesh.eList[3].vals = negYvals\\n mesh.eList[3].normals = negYnormals\\n mesh.eList[3].J = negYJ\\n \\n # z=+1 side\\n def posZvals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1)\\n yb=np.array(-xi2)\\n zb=np.ones(xi1.shape)\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n return np.vstack([x,y,z])\\n def posZnormals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1);yb=np.array(-xi2);zb=np.ones(xi1.shape);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n dxdxi2 = -1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\\n dydxi2 = -1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\\n dzdxi2 = -1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n magnitude = np.sqrt(np.sum(J**2,axis=1))\\n return J.T/magnitude\\n def posZJ(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1);yb=np.array(-xi2);zb=np.ones(xi1.shape);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n dxdxi2 = -1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\\n dydxi2 = -1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\\n dzdxi2 = -1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n return np.sqrt(np.sum(J**2,axis=1))\\n mesh.eList[4].vals = posZvals\\n mesh.eList[4].normals = posZnormals\\n mesh.eList[4].J = posZJ\\n \\n # z=-1 side\\n def negZvals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1);yb=np.array(xi2);zb=-np.ones(xi1.shape);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n x = xb*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n y = yb*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n z = zb*np.sqrt(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)\\n return np.vstack([x,y,z])\\n def negZnormals(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1);yb=np.array(xi2);zb=-np.ones(xi1.shape);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\\n dydxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\\n dzdxi2 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n magnitude = np.sqrt(np.sum(J**2,axis=1))\\n return J.T/magnitude\\n def negZJ(xi1,xi2):\\n xi1=np.asarray(xi1,np.float).reshape(-1,)\\n xi2=np.asarray(xi2,np.float).reshape(-1,)\\n xb=np.array(xi1);yb=np.array(xi2);zb=-np.ones(xi1.shape);\\n xx=xb**2;yy=yb**2;zz=zb**2;\\n dxdxi1 = 1.0*np.sqrt(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)\\n dxdxi2 = 1.0*xb*0.5*(1.0 - yy/2.0 - zz/2.0 + yy*zz/3.0)**-0.5 * (-yb+2.0*yb*zz/3.0)\\n dydxi1 = 1.0*yb*0.5*(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)**-0.5 * (-xb+2.0*xb*zz/3.0)\\n dydxi2 = 1.0*np.sqrt(1.0 - xx/2.0 - zz/2.0 + xx*zz/3.0)\\n dzdxi1 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-xb+2.0*xb*yy/3.0)\\n dzdxi2 = 1.0*zb*0.5*(1.0 - xx/2.0 - yy/2.0 + xx*yy/3.0)**-0.5 * (-yb+2.0*xx*yb/3.0)\\n J = np.array([[dxdxi1,dxdxi2],[dydxi1,dydxi2],[dzdxi1,dzdxi2]]).T\\n J = np.cross(J[:,0,:],J[:,1,:])\\n return np.sqrt(np.sum(J**2,axis=1))\\n mesh.eList[5].vals = negZvals\\n mesh.eList[5].normals = negZnormals\\n mesh.eList[5].J = negZJ\\n \\n for e in mesh.eList:\\n e.ExactElement = True\\n \\n return mesh\",\n \"def get_correct_coords(start_x=0,viewing_distance=12.0,field_height=10,field_width=10,pixel_width=0.282,pixel_height=0.282,**config):\\n \\n x = (start_x + np.arange(np.ceil(-field_width/2.0),np.ceil(field_width/2.0),1))*pixel_width\\n y = np.arange(np.ceil(-field_height/2.0),np.ceil(field_height/2.0),1)*pixel_height\\n x,y = np.meshgrid(x,y)\\n coords = np.vstack((x.ravel(),y.ravel())).T\\n return coords\",\n \"def sample_camera_positions(device,\\n bs=1,\\n r=1,\\n horizontal_stddev=1,\\n vertical_stddev=1,\\n horizontal_mean=math.pi * 0.5,\\n vertical_mean=math.pi * 0.5,\\n mode='normal'):\\n\\n if mode == 'uniform':\\n theta = (torch.rand((bs, 1), device=device) - 0.5) \\\\\\n * 2 * horizontal_stddev \\\\\\n + horizontal_mean\\n phi = (torch.rand((bs, 1), device=device) - 0.5) \\\\\\n * 2 * vertical_stddev \\\\\\n + vertical_mean\\n\\n elif mode == 'normal' or mode == 'gaussian':\\n theta = torch.randn((bs, 1), device=device) \\\\\\n * horizontal_stddev \\\\\\n + horizontal_mean\\n phi = torch.randn((bs, 1), device=device) \\\\\\n * vertical_stddev \\\\\\n + vertical_mean\\n\\n elif mode == 'hybrid':\\n if random.random() < 0.5:\\n theta = (torch.rand((bs, 1), device=device) - 0.5) \\\\\\n * 2 * horizontal_stddev * 2 \\\\\\n + horizontal_mean\\n phi = (torch.rand((bs, 1), device=device) - 0.5) \\\\\\n * 2 * vertical_stddev * 2 \\\\\\n + vertical_mean\\n else:\\n theta = torch.randn((bs, 1), device=device) * horizontal_stddev + horizontal_mean\\n phi = torch.randn((bs, 1), device=device) * vertical_stddev + vertical_mean\\n\\n elif mode == 'truncated_gaussian':\\n theta = truncated_normal_(torch.zeros((bs, 1), device=device)) \\\\\\n * horizontal_stddev \\\\\\n + horizontal_mean\\n phi = truncated_normal_(torch.zeros((bs, 1), device=device)) \\\\\\n * vertical_stddev \\\\\\n + vertical_mean\\n\\n elif mode == 'spherical_uniform':\\n theta = (torch.rand((bs, 1), device=device) - .5) \\\\\\n * 2 * horizontal_stddev \\\\\\n + horizontal_mean\\n v_stddev, v_mean = vertical_stddev / math.pi, vertical_mean / math.pi\\n v = ((torch.rand((bs, 1), device=device) - .5) * 2 * v_stddev + v_mean)\\n v = torch.clamp(v, 1e-5, 1 - 1e-5)\\n phi = torch.arccos(1 - 2 * v)\\n\\n elif mode == 'mean':\\n # Just use the mean.\\n theta = torch.ones((bs, 1), device=device, dtype=torch.float) * horizontal_mean\\n phi = torch.ones((bs, 1), device=device, dtype=torch.float) * vertical_mean\\n else:\\n assert 0\\n\\n phi = torch.clamp(phi, 1e-5, math.pi - 1e-5)\\n\\n output_points = torch.zeros((bs, 3), device=device) # (bs, 3)\\n output_points[:, 0:1] = r * torch.sin(phi) * torch.cos(theta) # x\\n output_points[:, 2:3] = r * torch.sin(phi) * torch.sin(theta) # z\\n output_points[:, 1:2] = r * torch.cos(phi) # y\\n\\n return output_points, phi, theta\",\n \"def magn(names, values, data, model_key, plot_key=False):\\n # Making sure number of parameters matches number of names given:\\n assert len(names) == len(values), \\\"len(names) != len(values) in datasim.magn\\\"\\n\\n zpicks = data['zpicks']\\n # Corrected absolute magnitude M of SN.\\n M = values[0]\\n\\n# dlpc, da, integrated_zpicks, integrated_dlpc, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\\n\\n dlpc, da, plot_var = zodesolve.zodesolve(names, values, zpicks, model_key, plot_key)\\n\\n # Calculating apparent magnitudes of supernovae at the simulated\\n # luminosity distances using the distance modulus formula.\\n mag = 5 * np.log10(dlpc/10) + M\\n# integrated_mag = 5 * np.log10(integrated_dlpc/10) + M\\n# print('redshift =',zpicks[-1],'da =', da[-1])\\n\\n# # plotting interpoated data vs input and full\\n# import matplotlib.pyplot as plt\\n# import matplotlib as mpl\\n# #mpl.style.use('default') # has to be switched on to set figure size\\n# mpl.style.use('fivethirtyeight')\\n# plt.rcParams['axes.facecolor'] = 'white'\\n# plt.rcParams['figure.facecolor'] = 'white'\\n# plt.rcParams['grid.color'] = 'white'\\n#\\n# print('integrated_zpicks',integrated_zpicks[0])\\n# print('zpicks', zpicks[0])\\n#\\n# plt.figure()\\n# plt.scatter(integrated_zpicks, integrated_mag, s=70, label='integrated', c=\\\"C{}\\\".format(0))\\n# plt.plot(zpicks, mag, label='interpolated', linestyle='-', c=\\\"C{}\\\".format(1))\\n# plt.legend()\\n\\n if plot_key:\\n # Plotting evolution of parameters in the model.\\n import plots\\n plots.modelcheck(mag, zpicks, plot_var, model_key)\\n\\n return mag, da\",\n \"def calculate_useful_stuff(self):\\n\\n self.pos = self.pair[1].position - self.pair[0].position\\n self.vel = self.pair[1].velocity - self.pair[0].velocity\\n\\n self.r = self.pos.length()\\n self.v = self.vel.length()\\n self.inv_r = 1.0 / self.r\\n\\n self.rvec = self.pos * self.inv_r\\n self.rdot = (self.rvec * self.vel).sum() * self.rvec\\n self.rdot_mag = self.rdot.length()\\n\\n self.vth = self.vel - self.rdot\\n self.vth_mag = self.vth.length()\\n self.vth_vec = self.vth / self.vth_mag\",\n \"def trap_depth_old(V,X,Y,Z,Im,Jm,Km,debug=False): \\n from project_parameters import debug\\n #from all_functions import sum_of_e_field\\n def a(a,N):\\n \\\"\\\"\\\"Shortcut function to convert array x into a row vector.\\\"\\\"\\\" \\n a=np.ravel(a, order='F') # Same order\\n return a\\n def index_sort(y,x):\\n \\\"\\\"\\\"Takes in two lists of the same length and returns y sorted by the indexing of x sorted.\\\"\\\"\\\"\\n xs=np.sort(x)\\n ix=np.argsort(x)\\n ys=np.ones(len(y)) #Sorted by the sorting defined by f being sorted. \\n for i in range(len(y)):\\n j=ix[i]\\n ys[i]=y[j]\\n return ys\\n if len(V.shape)!=3:\\n return('Problem with find_saddle.py dimensionalities.\\\\n')\\n N1,N2,N3=V.shape\\n N=N1*N2*N3\\n f=V\\n [Ex,Ey,Ez]=np.gradient(f,abs(X[1]-X[0]),abs(Y[1]-Y[0]),abs(Z[1]-Z[0]))\\n E=np.sqrt(Ex**2+Ey**2+Ez**2)\\n fs,Es=a(f,N),a(E,N) # Convert 3D to 1D array\\n fs,Es=np.real(fs),np.real(Es)\\n # identify the escape position and height by checking each point\\n minElectricField=max(fs) # initialize as maximum E field magnitude\\n distance=0\\n escapeHeight=1\\n escapePosition=[0,0,0]\\n for i in range(N1):\\n for j in range(N2):\\n for k in range(N3):\\n if [i,j,k]==[Im,Jm,Km]:\\n Vm=V[i,j,k]\\n elif E[i,j,k]<minElectricField:\\n minElectricField=E[i,j,k]\\n escapeHeight=V[i,j,k]\\n escapePosition=[i,j,k]\\n distance=abs(Im+Jm+Km-i-j-k) \\n if debug.trap_depth: # plot sortings of potential and electric field to view escape position\\n plt.plot(np.sort(fs)) \\n plt.title('sorted potential field')\\n plt.show()\\n plt.plot(np.sort(Es)) \\n plt.title('sorted electric field')\\n plt.show()\\n q1=index_sort(fs,Es) \\n plt.title('potential field sorted by sorted indexing of electric field')\\n plt.plot(q1)\\n plt.show()\\n q2=index_sort(Es,fs) \\n plt.title('electric field sorted by sorted indexing of potential field')\\n plt.plot(q2)\\n plt.show() \\n check=1 \\n if debug.trap_depth: \\n print minElectricField,escapeHeight,escapePosition,distance \\n if distance<check:\\n print('trap_depth.py: Escape point too close to trap minimum. Improve grid resolution or extend grid.')\\n if escapeHeight>0.2:\\n print('trap_depth.py: Escape point parameter too high. Improve grid resolution or extend grid.')\\n D=escapeHeight-Vm\\n [Ie,Je,Ke]=escapePosition\\n [Xe,Ye,Ze]=[X[Ie],Y[Je],Z[Ke]] \\n return [D,Xe,Ye,Ze]\",\n \"def test_jam_axi_rms():\\n np.random.seed(123)\\n xbin, ybin = np.random.uniform(low=[-55, -40], high=[55, 40], size=[1000, 2]).T\\n\\n inc = 60. # Assumed galaxy inclination\\n r = np.sqrt(xbin**2 + (ybin/np.cos(np.radians(inc)))**2) # Radius in the plane of the disk\\n a = 40 # Scale length in arcsec\\n vr = 2000*np.sqrt(r)/(r+a) # Assumed velocity profile\\n vel = vr * np.sin(np.radians(inc))*xbin/r # Projected velocity field\\n sig = 8700/(r+a) # Assumed velocity dispersion profile\\n rms = np.sqrt(vel**2 + sig**2) # Vrms field in km/s\\n\\n surf = np.array([39483., 37158., 30646., 17759., 5955.1, 1203.5, 174.36, 21.105, 2.3599, 0.25493])\\n sigma = np.array([0.153, 0.515, 1.58, 4.22, 10, 22.4, 48.8, 105, 227, 525])\\n qObs = np.full_like(sigma, 0.57)\\n\\n distance = 16.5 # Assume Virgo distance in Mpc (Mei et al. 2007)\\n mbh = 1e8 # Black hole mass in solar masses\\n beta = np.full_like(surf, 0.3)\\n\\n surf_lum = surf # Assume self-consistency\\n sigma_lum = sigma\\n qobs_lum = qObs\\n surf_pot = surf\\n sigma_pot = sigma\\n qobs_pot = qObs\\n\\n sigmapsf = 0.6\\n pixsize = 0.8\\n goodbins = r > 10 # Arbitrarily exclude the center to illustrate how to use goodbins\\n\\n # The model is similar but not identical to the adopted kinematics!\\n rmsModel, ml, chi2, flux = jam_axi_rms(\\n surf_lum, sigma_lum, qobs_lum, surf_pot, sigma_pot, qobs_pot,\\n inc, mbh, distance, xbin, ybin, plot=True, rms=rms, sigmapsf=sigmapsf,\\n beta=beta, pixsize=pixsize, tensor='zz', goodbins=goodbins)\\n plt.pause(0.01)\",\n \"def calc_magnitude(box,octant):\\n # Read the Mi(z=2) magnitudes for the box.\\n miz2 = FH.read_file(box)['Miz2'][:]\\n # Read the index for each QSO in the octant, and get the Mi(z=2).\\n data = FH.read_file(octant)\\n zz = data['Z']\\n dmod = data['DMOD']\\n miz2 = miz2[data['INDX']]\\n # Now convert to apparent i-band magnitude using the k-correction.\\n # If a tabulated k-correction is available, use that, otherwise\\n # default to a power-law continuum approximation.\\n # See discussion in Ross++13, Appendix B and Section 4.\\n kfile=os.getenv('MOCKINGDESI_BASE')+\\\"/data/qso-iband-k-correction.txt\\\"\\n if os.path.exists(kfile):\\n print(\\\"Using K-correction from \\\"+kfile)\\n kcorr = np.loadtxt(kfile)\\n kcorr = np.interp(zz,kcorr[:,1],kcorr[:,2])\\n else:\\n print(\\\"Using power-law K-correction\\\")\\n alpha = -0.5\\n kcorr = -2.5*(1+alpha)*np.log10( (1+zz)/(1+2.0) )\\n gmi = np.poly1d([0.1502,-0.9886,2.147,-1.758,0.6397])\\t# See notes.\\n rmi = np.poly1d([-0.1482,1.636,-6.716,12.55,-10.39,3.017])\\n magi = miz2 + dmod + kcorr\\t# e.g. Ross++13, Eq. 5\\n magg = magi + gmi(zz.clip(0.5,3.5))\\n magr = magi + rmi(zz.clip(0.5,3.5))\\n # and write the results\\n data = {}\\n data['GMAG'] = magg.astype('f4')\\n data['RMAG'] = magr.astype('f4')\\n FH.write_file(octant,data)\\n #\",\n \"def GetDetectorData(detectorName):\\n\\n # Allocate direction vectors and position of IFO given detectorName\\n detPosVector = np.zeros(3)\\n nx = np.zeros(3)\\n ny = np.zeros(3)\\n\\n ################# aLIGO HANFORD #############\\n if detectorName == 'H1':\\n\\tnx[0] = -0.22389266154\\n\\tnx[1] = 0.79983062746\\n\\tnx[2] = 0.55690487831\\n\\n\\tny[0] = -0.91397818574\\n\\tny[1] = 0.02609403989\\n\\tny[2] = -0.40492342125\\n\\n\\tdetPosVector[0] = -2.16141492636e6\\n\\tdetPosVector[1] = -3.83469517889e6\\n\\tdetPosVector[2] = 4.60035022664e6\\n ################# aLIGO LIVINGSTON ##########\\n elif detectorName == 'L1':\\n\\tnx[0] = -0.95457412153\\n\\tnx[1] = -0.14158077340\\n\\tnx[2] = -0.26218911324\\n\\n\\tny[0] = 0.29774156894\\n\\tny[1] = -0.48791033647 \\n\\tny[2] = -0.82054461286\\n\\n\\tdetPosVector[0] = -7.42760447238e4\\n\\tdetPosVector[1] = -5.49628371971e6\\n\\tdetPosVector[2] = 3.22425701744e6\\n ################# AdvVIRGO ##################\\n elif detectorName == 'V1':\\n\\tnx[0] = -0.70045821479\\n nx[1] = 0.20848948619\\n nx[2] = 0.68256166277\\n\\n ny[0] = -0.05379255368 \\n ny[1] = -0.96908180549\\n ny[2] = 0.24080451708\\n\\n detPosVector[0] = 4.54637409900e6\\n detPosVector[1] = 8.42989697626e5\\n detPosVector[2] = 4.37857696241e6\\n ################# INDIGO ####################\\n elif detectorName == 'I1':\\n\\t# Not cached LIGO detector - construct x, nx and ny from other\\n\\t# quantities\\n\\tvxLat = (14. + 14./60.)*(np.pi/180.) # Vertex latitude\\n\\tvxLon = (76. + 26./60.)*(np.pi/180.) # Vertex longitude\\n\\tvxElev = 0. # Vertex elevation\\n\\txAlt = 0. # Altitude of x-arm\\n\\tyAlt = 0. # Altitude of y-arm\\n\\txAz = np.pi/2. # Azimuth of x-arm\\n\\tyAz = 0. # Azimuth of y-arm\\n\\n\\tcosLat = np.cos(vxLat)\\n sinLat = np.sin(vxLat)\\n cosLon = np.cos(vxLon)\\n sinLon = np.sin(vxLon)\\n\\n ellDenom = np.sqrt(AWGS84*AWGS84*cosLat*cosLat + \\\\\\n BWGS84*BWGS84*sinLat*sinLat)\\n locRho = cosLat*(AWGS84*AWGS84/ellDenom + vxElev)\\n \\n # Position\\n detPosVector[0] = locRho*cosLon\\n detPosVector[1] = locRho*sinLon\\n detPosVector[2] = sinLat*(BWGS84*BWGS84/ellDenom + vxElev)\\n\\n # x-Arm vector\\n cosxAlt = np.cos(xAlt)\\n sinxAlt = np.sin(xAlt)\\n cosxAz = np.cos(xAz)\\n sinxAz = np.sin(xAz)\\n uxNorth = cosxAlt*cosxAz\\n uxEast = cosxAlt*sinxAz\\n uxRho = -sinLat*uxNorth + cosLat*sinxAlt\\n\\n nx[0] = cosLon*uxRho - sinLon*uxEast\\n nx[1] = sinLon*uxRho + cosLon*uxEast\\n nx[2] = cosLat*uxNorth + sinLat*sinxAlt\\n\\n # y-Arm vector\\n cosyAlt = np.cos(yAlt)\\n sinyAlt = np.sin(yAlt)\\n cosyAz = np.cos(yAz)\\n sinyAz = np.sin(yAz)\\n uyNorth = cosyAlt*cosyAz\\n uyEast = cosyAlt*sinyAz\\n uyRho = -sinLat*uyNorth + cosLat*sinyAlt\\n\\n ny[0] = cosLon*uyRho - sinLon*uyEast\\n ny[1] = sinLon*uyRho + cosLon*uyEast\\n ny[2] = cosLat*uyNorth + sinLat*sinyAlt\\n\\n ################# KAGRA #####################\\n elif detectorName == 'K1':\\n\\t# Not cached LIGO detector - construct x, nx and ny from other\\n # quantities\\n vxLat = (36.25)*(np.pi/180.) # Vertex latitude\\n vxLon = (137.18)*(np.pi/180.) # Vertex longitude\\n vxElev = 0. # Vertex elevation\\n xAlt = 0. # Altitude of x-arm\\n yAlt = 0. # Altitude of y-arm\\n xMid = 1500. # Midpoint of x-arm\\n yMid = 1500. # Midpoint of y-arm\\n xAz = 19.*(np.pi/180.) + np.pi/2. # Azimuth of x-arm\\n yAz = 19.*(np.pi/180.) # Azimuth of y-arm\\n\\n cosLat = np.cos(vxLat)\\n\\tsinLat = np.sin(vxLat)\\n\\tcosLon = np.cos(vxLon)\\n\\tsinLon = np.sin(vxLon)\\n\\n\\tellDenom = np.sqrt(AWGS84*AWGS84*cosLat*cosLat + \\\\\\n\\t\\t BWGS84*BWGS84*sinLat*sinLat)\\n\\tlocRho = cosLat*(AWGS84*AWGS84/ellDenom + vxElev)\\n\\n\\t# Position\\n\\tdetPosVector[0] = locRho*cosLon\\n\\tdetPosVector[1] = locRho*sinLon\\n\\tdetPosVector[2] = sinLat*(BWGS84*BWGS84/ellDenom + vxElev)\\n\\n\\t# x-Arm vector\\n\\tcosxAlt = np.cos(xAlt)\\n\\tsinxAlt = np.sin(xAlt)\\n\\tcosxAz = np.cos(xAz)\\n\\tsinxAz = np.sin(xAz) \\n\\tuxNorth = cosxAlt*cosxAz\\n\\tuxEast = cosxAlt*sinxAz\\n\\tuxRho = -sinLat*uxNorth + cosLat*sinxAlt\\n\\n\\tnx[0] = cosLon*uxRho - sinLon*uxEast\\n\\tnx[1] = sinLon*uxRho + cosLon*uxEast\\n\\tnx[2] = cosLat*uxNorth + sinLat*sinxAlt\\n\\n\\t# y-Arm vector\\n\\tcosyAlt = np.cos(yAlt)\\n sinyAlt = np.sin(yAlt)\\n cosyAz = np.cos(yAz)\\n sinyAz = np.sin(yAz)\\n\\tuyNorth = cosyAlt*cosyAz\\n uyEast = cosyAlt*sinyAz\\n uyRho = -sinLat*uyNorth + cosLat*sinyAlt\\n\\n ny[0] = cosLon*uyRho - sinLon*uyEast\\n ny[1] = sinLon*uyRho + cosLon*uyEast\\n ny[2] = cosLat*uyNorth + sinLat*sinyAlt\\n\\n # Compute detRespTensor as \\n # detRespTensor = 0.5(nx \\\\outerprod nx - ny \\\\outerprod ny)\\n detRespTensor = np.zeros((3,3),float)\\n for i in range(0,3):\\n\\tfor j in range(0,3):\\n\\t detRespTensor[i,j] = (nx[i]*nx[j] - ny[i]*ny[j])*0.5\\n\\n return detRespTensor,detPosVector\",\n \"def calc_body_pos(component, time):\\r\\n # Convert to radians\\r\\n M = radians(eval(component.orbit['M'])(time))\\r\\n w = radians(eval(component.orbit['w'])(time))\\r\\n i = radians(eval(component.orbit['i'])(time))\\r\\n N = radians(eval(component.orbit['N'])(time))\\r\\n a = component.orbit['a']\\r\\n e = eval(component.orbit['e'])(time)\\r\\n # Compute eccentric anomaly\\r\\n E = M + e * sin(M) * (1.0 + e * cos(M))\\r\\n if degrees(E) > 0.05:\\r\\n E = compute_e(E, M, e)\\r\\n # http://stjarnhimlen.se/comp/tutorial.html\\r\\n # Compute distance and true anomaly\\r\\n xv = a * (cos(E) - e)\\r\\n yv = a * (sqrt(1.0 - e * e) * sin(E))\\r\\n v = atan2(yv, xv)\\r\\n r = sqrt(xv * xv + yv * yv)\\r\\n xh = r * (cos(N) * cos(v + w) - sin(N) * sin(v + w) * cos(i))\\r\\n yh = r * (sin(N) * cos(v + w) + cos(N) * sin(v + w) * cos(i))\\r\\n if is2d:\\r\\n zh = 0\\r\\n else:\\r\\n zh = r * (sin(v + w) * sin(i))\\r\\n '''The above assumes looking \\\"down\\\" on the solar system where x and y are\\r\\n the circle and z = 0 is on the heliocentric ecliptic. Panda3d uses the above.\\r\\n Opengl is y up and z depth so we switch the y and z coordinates below..'''\\r\\n #TODO: z+ is out of the screen so check if we need to flip the sign of zh\\r\\n '''xh = r * (cos(N) * cos(v + w) - sin(N) * sin(v + w) * cos(i))\\r\\n zh = r * (sin(N) * cos(v + w) + cos(N) * sin(v + w) * cos(i))\\r\\n if is2d:\\r\\n yh = 0\\r\\n else:\\r\\n yh = r * (sin(v + w) * sin(i))'''\\r\\n position = LPoint3d(xh, yh, zh)\\r\\n # If we are not a moon then our orbits are done in au.\\r\\n # Moons are done in km\\r\\n # Our units in panda are m, so we convert to m\\r\\n if component.kind != cel_comp.TYPES['moon']:\\r\\n position *= 149598000\\r\\n position *= 1000\\r\\n return position\",\n \"def get_vector_field(self, key):\\n f1 = self.get_field(key + '1')\\n f2 = self.get_field(key + '2')\\n f3 = self.get_field(key + '3')\\n x, y, z = self.get_cell_center_coordinates()\\n if self.geometry == 'cartesian':\\n fx = f1\\n fy = f2\\n fz = f3\\n elif self.geometry == 'spherical':\\n \\\"\\\"\\\"\\n http://en.wikipedia.org/wiki/\\n List_of_common_coordinate_transformations#To_Spherical_coordinates\\n \\\"\\\"\\\"\\n r2 = x**2 + y**2 + z**2\\n rh = [x/r2**0.5, y/r2**0.5, z/r2**0.5]\\n th = [x*z/r2*(x**2 + y**2)**-0.5,\\n y*z/r2*(x**2 + y**2)**-0.5,\\n -1./r2*(x**2 + y**2)**+0.5] \\n ph = [-y/(x**2 + y**2)+0*r2, x/(x**2 + y**2)+0*r2, 0*r2]\\n fx = f1*rh[0] + f2*th[0] + f3*ph[0]\\n fy = f1*rh[1] + f2*th[1] + f3*ph[1]\\n fz = f1*rh[2] + f2*th[2] + f3*ph[2]\\n return fx, fy, fz\",\n \"def main():\\n cam = Realsense()\\n # cam.access_intr_and_extr()\\n profile = cam.pipeline.start(cam.config)\\n depth_sensor = profile.get_device().first_depth_sensor()\\n depth_scale = depth_sensor.get_depth_scale()\\n align_to = rs.stream.color\\n align = rs.align(align_to)\\n\\n objp = np.zeros((3*4,3), np.float32)\\n objp[:,:2] = np.mgrid[0:4,0:3].T.reshape(-1,2)\\n axis = np.float32([[1,0,0], [0,1,0], [0,0,-1]]).reshape(-1,3)\\n # print(objp)\\n\\n try:\\n while (True):\\n # detect ArUco markers in RGB images\\n frames = cam.pipeline.wait_for_frames()\\n aligned_frames = align.process(frames)\\n color_frame = aligned_frames.get_color_frame()\\n color_image = np.asanyarray(color_frame.get_data()) \\n frame = color_image\\n font = cv2.FONT_HERSHEY_SIMPLEX\\n corners, ids, rvecs, tvecs = cam.detect_markers_realsense(frame)\\n \\n if np.all(ids != None): # if markers are detected\\n for i in range(0, ids.size):\\n aruco.drawAxis(frame, cam.newcameramtx, cam.dist, rvecs[i],\\n tvecs[i], 0.1) # Draw axis\\n aruco.drawDetectedMarkers(frame, corners) # draw square around markers\\n\\n ###### DRAW ID #####\\n strg = ''\\n for i in range(0, ids.size):\\n strg += str(ids[i][0])+', '\\n\\n cv2.putText(frame, \\\"Id: \\\" + strg, (0,25), font, 1, (0,255,0), 2,\\n cv2.LINE_AA)\\n\\n\\t ###### Output marker positions in camera frame ######\\n \\t # output tvec\\n y0 = 60\\n dy = 40\\n for i in range(0, ids.size):\\n y = y0 + i*dy\\n cv2.putText(frame, str(tvecs[i][0]), (0, y), font, 1, (0,255,0),\\n 2, cv2.LINE_AA)\\n\\n else:\\n ##### DRAW \\\"NO IDS\\\" #####\\n cv2.putText(frame, \\\"No Ids\\\", (0,64), font, 1, (0,255,0), 2,\\n cv2.LINE_AA)\\n\\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n ret, corners = cv2.findChessboardCorners(gray, (4,3), None)\\n if ret == True:\\n corners2 = cv2.cornerSubPix(gray, corners,(11,11), (-1,-1),\\n cam.criteria)\\n corners2 = corners2[::-1]\\n # print(corners2)\\n # print(objp)\\n frame = cv2.drawChessboardCorners(frame, (4,3), corners2, ret)\\n # Find the rotation and translation vectors.\\n _, rvecs, tvecs = cv2.solvePnP(objp, corners2, cam.newcameramtx,\\n cam.dist)\\n rot, _ = cv2.Rodrigues(rvecs)\\n # print(rot)\\n # project 3D points to image plane\\n imgpts, jac = cv2.projectPoints(axis, rvecs, tvecs,\\n cam.newcameramtx, cam.dist)\\n frame = draw(frame, corners2, imgpts)\\n\\n # Display the resulting frame\\n cv2.imshow('frame',frame)\\n cv2.waitKey(5)\\n\\n # When everything done, release the capture\\n cv2.destroyAllWindows()\\n\\n finally:\\n cam.pipeline.stop()\",\n \"def getCarLocation():\\n cams = CAMS\\n img1, img2 = cams[0].getImage(), cams[1].getImage()\\n potint1op, point2op = GetBalloonOld.getCar(img1), GetBalloonOld.getCar(\\n img2)\\n for j in range(len(point1op)):\\n point1op[j] = np.array(np.array([point1op[j][0], point1op[j][1]]))\\n for j in range(len(point2op)):\\n point2op[j] = np.array(np.array([point2op[j][0], point2op[j][1]]))\\n if len(point1op) == 0 or len(point2op) == 0:\\n return None\\n points = [[point1op[0]], [point2op[0]]]\\n car = getTargetsPlaces(copy.deepcopy(points))[0]\\n diff = abs(car[2] - CAR_Z)\\n for op1 in point1op:\\n for op2 in point2op:\\n testPoint = [[op1], [op2]]\\n testCar = getTargetsPlaces(copy.deepcopy(testPoint))[0]\\n testDiff = abs(testCar[2] - CAR_Z)\\n if testDiff < diff:\\n diff = testDiff\\n car = testCar\\n return car\",\n \"def force ( box, strain, r ):\\n\\n import numpy as np\\n from itertools import product\\n import math\\n \\n # It is assumed that positions are in units where box = 1\\n # Forces are calculated in units where sigma = 1 and epsilon = 1\\n # Lees-Edwards boundaries, in sliding brick arrangement\\n # Flow/gradient/vorticity directions are x/y/z == 0/1/2\\n # Uses neighbour lists\\n\\n n = r.shape[0]\\n\\n # Set up vectors to half the cells in neighbourhood of 3x3x3 cells in cubic lattice\\n # The cells are chosen so that if (d0,d1,d2) appears, then (-d0,-d1,-d2) does not.\\n # The last three cells are extra ones, to cope with the sheared system\\n d = np.array ( [ [ 0, 0, 0], [ 1, 0, 0], [ 1, 0, 1], [-1, 0, 1], [ 0, 0, 1], # 5 cells with d1=0\\n [ 1, 1, -1], [ 1, 1, 0], [ 1, 1, 1], # 3 cells with d0= 1, d1=1\\n [ 0, 1, -1], [ 0, 1, 0], [ 0, 1, 1], # 3 cells with d0= 0, d1=1\\n [-1, 1, -1], [-1, 1, 0], [-1, 1, 1], # 3 cells with d0=-1, d1=1\\n [-2, 1, -1], [-2, 1, 0], [-2, 1, 1] ] ) # 3 cells with d0=-2, d1=1\\n\\n r[:,0] = r[:,0] - np.rint(r[:,1])*strain # Extra correction in box=1 units\\n r = r - np.rint(r) # Ensure all atoms in periodic box\\n \\n sr2_ovr = 1.77 # Overlap threshold (pot > 100)\\n r_cut_box = r_cut / box\\n r_cut_box_sq = r_cut_box ** 2\\n box_sq = box ** 2\\n\\n # Initialize\\n f = np.zeros_like(r)\\n total = PotentialType ( pot=0.0, vir=0.0, pyx=0.0, lap=0.0, ovr=False )\\n\\n # Calculate cell index triplets\\n sc = math.floor(box/r_cut) # Number of cells along box edge\\n assert sc >= 3, 'System is too small for cells' # Guard against box being too small\\n c = np.floor((r+0.5)*sc).astype(np.int_) # N*3 array of cell indices for all atoms\\n assert np.all(c>=0) and np.all(c<sc), 'Index error' # Simplistic \\\"guard\\\" against roundoff\\n\\n shift = math.floor(strain*sc) # Strain measured in cell lengths\\n\\n if fast:\\n \\n # Build list of arrays, each array holding positions of atoms in a cell\\n # At the same time, define a matching set of force arrays in each cell\\n # i and j number the atoms in each cell; we do not refer explicitly to indices in r\\n rc, fc = [], [] # Initially empty lists of positions and forces\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n rc.append(r[mask,:]) # Copy atom coordinates into array, add to list\\n fc.append(np.zeros_like(rc[-1])) # Zero corresponding forces, add to list\\n\\n for ci1, rci in enumerate(rc): # Loop over i-cells, getting all atoms in each i-cell as an array\\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\\n if rci.size==0: # Handle empty cell\\n continue\\n\\n # Set up correct neighbour cell indices\\n if ci[1]==sc-1: # i-cell is in the top layer\\n dd = d.copy() # Standard list copied, including extra 3 cells\\n dd[5:,0] = d[5:,0] - shift # All those looking up need adjustment in the x direction\\n else: # i-cell is not in top layer\\n dd = d[:-3,:].copy() # Last three extra cells are not needed; shift is not needed\\n \\n for dj in dd: # Loop over neighbouring j-cells\\n cj = ci + dj # Compute neighbour j-cell triple-indices\\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert j-cell to single-index\\n rcj = rc[cj1] # Get atoms in j-cell as an array\\n if rcj.size==0: # Handle empty cell\\n continue\\n\\n rij = rci[:,np.newaxis,:]-rcj[np.newaxis,:,:] # Separation vectors for all i and j\\n rij[:,:,0] = rij[:,:,0] - np.rint(rij[:,:,1])*strain # Extra correction in box=1 units\\n rij = rij - np.rint(rij) # PBCs in box=1 units\\n rij_sq = np.sum(rij**2,axis=2) # Squared separations\\n in_range = rij_sq < r_cut_box_sq # Set flags for within cutoff\\n\\n if ci1==cj1:\\n np.fill_diagonal(in_range,False) # Eliminate i==j when i-cell==j-cell\\n np.fill_diagonal(rij_sq,1.0) # Avoid divide-by-zero below\\n\\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\\n rij = rij * box # Now in sigma=1 units\\n sr2 = np.where ( in_range, 1.0/rij_sq, 0.0 ) # (sigma/rij)**2, only if in range\\n ovr = sr2 > sr2_ovr # Overlap if too close\\n sr6 = sr2 ** 3\\n sr12 = sr6 ** 2\\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\\n vir = pot + sr12 # LJ virial\\n pot = np.where ( in_range, pot+0.25, 0.0 ) # WCA LJ pair potential (cut-and-shifted)\\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\\n fij = vir * sr2 # LJ scalar part of forces\\n fij = rij * fij[:,:,np.newaxis] # LJ pair forces\\n pyx = rij[:,:,1]*fij[:,:,0] # Off-diagonal element of pressure tensor\\n\\n if ci1==cj1: # Correct for double-counting ij and ji when i-cell==j-cell\\n fij = fij / 2\\n total = total + PotentialType ( pot=np.sum(pot)/2, vir=np.sum(vir)/2, \\n pyx=np.sum(pyx)/2, lap=np.sum(lap)/2, ovr=np.any(ovr) )\\n else:\\n total = total + PotentialType ( pot=np.sum(pot), vir=np.sum(vir), \\n pyx=np.sum(pyx), lap=np.sum(lap), ovr=np.any(ovr) )\\n\\n fc[ci1][:,:] = fc[ci1][:,:] + np.sum(fij,axis=1) # Aggregate force on atoms in i-cell\\n fc[cj1][:,:] = fc[cj1][:,:] - np.sum(fij,axis=0) # Aggregate force on atoms in j-cell\\n\\n # Copy forces from list of cell arrays to main force array\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n ci1 = np.ravel_multi_index(ci,(sc,sc,sc),mode='wrap') # Single-index\\n f[mask,:] = fc[ci1] # Copy atom forces from correct cell\\n\\n else:\\n \\n # Build list of arrays, each array holding indices of atoms in a cell\\n # ki and kj are atom indices in the r array; i and j number the atoms in each cell\\n k_array = np.arange(n) # Atom indices 0..N-1\\n kc = [] # Initially empty list of indices\\n for ci in product(range(sc),repeat=3): # Triple loop over cells\\n mask = np.all(c==ci,axis=1) # Mask identifies atoms in this cell\\n kc.append(k_array[mask]) # Copy atom indices into array, add to list\\n\\n for ci1, kci in enumerate(kc): # Loop over i-cells, getting atom indices as an array\\n ci = np.unravel_index(ci1,(sc,sc,sc)) # Get i-cell triple-indices\\n\\n # Set up correct neighbour cell indices\\n if ci[1]==sc-1: # i-cell is in the top layer\\n dd = d # Standard list copied, including extra 3 cells\\n dd[5:,0] = dd[5:,0] - shift # All those looking up need adjustment in the x direction\\n else:\\n dd = d[:-3,:] # Last three extra cells are not needed; shift is not needed\\n\\n for dj in dd: # Loop over neighbouring j-cells\\n cj = ci + dj # Compute neighbour j-cell triple-indices\\n cj1 = np.ravel_multi_index(cj,(sc,sc,sc),mode='wrap') # Convert to single-index\\n kcj = kc[cj1] # Get indices of atoms in j-cell as an array\\n\\n for i, ki in enumerate(kci): # Loop over individual atoms in i-cell\\n j0 = i+1 if cj1==ci1 else 0 # Only look upwards if i-cell==j-cell\\n if j0 >= kcj.size: # Handles (redundantly) empty j-cell and the case \\n continue # where j-cell==i-cell and i is last atom\\n\\n for kj in kcj[j0:]: # Loop over individual atoms in j-cell\\n rij = r[ki,:]-r[kj,:] # Separation vector\\n rij[0] = rij[0] - np.rint(rij[1])*strain # Extra correction in box=1 units\\n rij = rij - np.rint(rij) # Periodic boundary conditions in box=1 units\\n rij_sq = np.sum(rij**2) # Squared separation\\n\\n if rij_sq < r_cut_box_sq: # Check within cutoff\\n rij_sq = rij_sq * box_sq # Now in sigma=1 units\\n rij = rij * box # Now in sigma=1 units\\n sr2 = 1.0 / rij_sq # (sigma/rij)**2\\n ovr = sr2 > sr2_ovr # Overlap if too close\\n sr6 = sr2 ** 3\\n sr12 = sr6 ** 2\\n pot = sr12 - sr6 # LJ potential (cut but not shifted)\\n vir = pot + sr12 # LJ virial\\n pot = pot + 0.25 # WCA LJ potential (cut-and-shifted)\\n lap = ( 22.0*sr12 - 5.0*sr6 ) * sr2 # LJ Laplacian\\n fij = rij * vir * sr2 # LJ forces\\n pyx = rij[1]*fij[0] # Off-diagonal element of pressure tensor\\n total = total + PotentialType ( pot=pot, vir=vir, pyx=pyx, lap=lap, ovr=ovr )\\n f[ki,:] = f[ki,:] + fij\\n f[kj,:] = f[kj,:] - fij\\n\\n # Multiply results by numerical factors\\n f = f * 24.0 # 24*epsilon\\n total.pot = total.pot * 4.0 # 4*epsilon\\n total.vir = total.vir * 24.0 / 3.0 # 24*epsilon and divide virial by 3\\n total.pyx = total.pyx * 24.0 # 24*epsilon\\n total.lap = total.lap * 24.0 * 2.0 # 24*epsilon and factor 2 for ij and ji\\n \\n return total, f\",\n \"def add_cam(self, xpos, ypos, follower_len, bumps=[], horizontal=False, reverse_direction=False, axis_offset=0, axis=True, bump_height=3, slow_rise=False):\\n attachment_body = self.groundBody\\n offset = 0\\n if not horizontal:\\n offset = -0.25\\n if reverse_direction:\\n offset = 0.5\\n for b in range(0,len(bumps)):\\n bumps[b] = (bumps[b][0] + offset, bumps[b][1])\\n radius = 30\\n bump_height = radius+bump_height\\n disc_fixture = fixtureDef(shape=circleShape(radius=radius, pos=(0,0)),density=1.0,filter=filters[0])\\n bump_fixtures = []\\n\\n if slow_rise:\\n ang=bumps[0][0]\\n bump_points = [( radius*math.cos(-ang*math.pi*2), radius*math.sin(-ang*math.pi*2)) ]\\n height = radius\\n for point in range(0,14):\\n ang += 0.015\\n height += 0.3\\n bump_points.append( ( height*math.cos(-ang*math.pi*2), height*math.sin(-ang*math.pi*2)) )\\n bump_points.append(( radius*math.cos(-ang*math.pi*2), radius*math.sin(-ang*math.pi*2)))\\n bump_fixtures.append(fixtureDef(shape=polygonShape(vertices=bump_points),density=0.0,filter=filters[0]))\\n else:\\n for (start, length) in bumps:\\n ang = start\\n bump_points = [( radius*math.cos(-ang*math.pi*2), radius*math.sin(-ang*math.pi*2)) ]\\n points = 1\\n # Max points in a polygon is 15 at the moment.\\n while ang < (start+length) and points < 15:\\n ang += 0.02\\n bump_points.append( ( bump_height*math.cos(-ang*math.pi*2), bump_height*math.sin(-ang*math.pi*2)) )\\n points += 1\\n if points == 15:\\n print(\\\"WARNING: Max points reached in cam bump; %2.2d%% of cam complete\\\"%(100*(ang-start)/length))\\n\\n bump_points.append(( radius*math.cos(-(ang+0.01)*math.pi*2), radius*math.sin(-(ang+0.01)*math.pi*2)))\\n f = fixtureDef(shape=polygonShape(vertices=bump_points),density=0.0,filter=filters[0], userData=(0,0,255))\\n bump_fixtures.append(f)\\n cam_body = self.add_multifixture(bump_fixtures + [disc_fixture], xpos, ypos, (0,255,0))\\n cam_driver = self.revolving_joint(attachment_body, cam_body, (xpos,ypos), motor=1, force=50)\\n cam_driver.motorSpeed = 0\\n follower_filter = filters[1]\\n if axis:\\n if horizontal:\\n axle_y = ypos+radius\\n if reverse_direction:\\n axle_x = xpos-radius-axis_offset-5\\n else:\\n axle_x = xpos+radius+axis_offset+2.5\\n follower_body = self.add_dynamic_polygon(box_polygon_shape(axle_x, axle_y-follower_len, 5, follower_len), 0, 0, filter=follower_filter)\\n follower_wheel = self.add_dynamic_circle(axle_x+2.5, axle_y-radius, 5)\\n self.revolving_joint(follower_wheel, follower_body, (axle_x+2.5,axle_y-radius), friction=False)\\n else:\\n axle_y = ypos+radius+axis_offset+2.5\\n axle_x = xpos-radius\\n follower_body = self.add_dynamic_polygon(box_polygon_shape(axle_x, axle_y, follower_len, 5), 0, 0, filter=follower_filter)\\n follower_wheel = self.add_dynamic_circle(axle_x+radius, axle_y+2.5, 5)\\n self.revolving_joint(follower_wheel, follower_body, (axle_x+radius,axle_y+2.5), friction=False)\\n\\n if horizontal:\\n follower_body.attachment_point=(axle_x, axle_y-follower_len)\\n else:\\n follower_body.attachment_point=(axle_x+follower_len, axle_y)\\n self.revolving_joint(attachment_body, follower_body, (axle_x+2.5,axle_y+2.5), friction=False)\\n print(\\\"Creating cam: xpos= {}, ypos= {}, axle_x = {} ,axle_y= {}, follower_len={}\\\".format(xpos, ypos, axle_x, axle_y, follower_len))\\n\\n self.all_cam_drives.append(cam_driver)\\n if axis:\\n return follower_body\\n else:\\n return None\",\n \"def blackbodyUV(temp):\\n lam=lambda wl: planckian(temp, wl)\\n xyz=spectrumToTristim(perfectrefl, lam)\\n uvy=xyzTouvY(xyz)\\n return [uvy[0], uvy[1]*2.0/3]\",\n \"def process_frame(self, raw_frame, detection_all):\\n \\n frame = raw_frame.copy()\\n h,w,_ = frame.shape\\n proximity = int(h/2.4)\\n pic_proximity = int(h/1.45)\\n min_distance = int(w/2)\\n\\n head_pos = (detection_all[4][0], detection_all[4][1])\\n hand_pos = (detection_all[3][0], detection_all[3][1])\\n \\n \\n #self.target_height = target_height\\n self.target_height = detection_all[4][3]\\n target_width = detection_all[4][2]\\n target = (detection_all[4][0], detection_all[4][1])\\n\\n ref_x = int(w/2)\\n ref_y = int(h*0.35)\\n \\n self.axis_speed = self.cmd_axis_speed.copy()\\n\\n #Is there a Picture Command ?\\n if self.picture_approach:\\n cls_number = int(self.classes_dict[self.picture_target])\\n print (str(self.picture_target) + 'is' + str(cls_number))\\n print (self.picture_target + ' values:' + str(detection_all[cls_number]))\\n \\n # If no pic target found --> rotate\\n if (detection_all[cls_number][0] + detection_all[cls_number][1]) == 0:\\n \\n log.info(f'searching for {self.picture_target}')\\n \\n if time.time() - self.search_start_time < 8: \\n self.axis_speed[\\\"yaw\\\"] = 60\\n else:\\n print('stopped searching after 8 seconds')\\n self.axis_speed[\\\"yaw\\\"] = 0\\n self.picture_approach = False\\n \\n # If pic target found set as new tracking target\\n else:\\n print('pic target found')\\n self.axis_speed[\\\"yaw\\\"] = 0\\n if self.timestamp_pic_target_found is None:\\n self.timestamp_pic_target_found = time.time()\\n\\n log.info(f'found {self.picture_target}')\\n target = (detection_all[cls_number][0], detection_all[cls_number][1])\\n self.target_height = detection_all[cls_number][3]\\n \\n #If Human Head:\\n if cls_number == 4:\\n self.keep_distance = pic_proximity*0.75\\n else:\\n self.keep_distance = pic_proximity\\n\\n self.pid_pitch = PID(0.15,0.0,0.1,setpoint=0,output_limits=(-30,30))\\n self.tracking = True\\n \\n # If voice command 'come home' activate RTH\\n if self.rth:\\n self.target_height = detection_all[4][3]\\n target_width = detection_all[4][2]\\n target = (detection_all[4][0], detection_all[4][1])\\n self.keep_distance = proximity*0.75\\n self.toggle_tracking(tracking=True)\\n\\n if self.timestamp_take_picture:\\n if time.time() - self.timestamp_take_picture > 2:\\n self.timestamp_take_picture = None\\n self.drone.take_picture()\\n else:\\n\\n if self.tracking: \\n if target != (0,0): \\n if self.distance_mode: \\n # Locked distance mode\\n if self.keep_distance is None:\\n self.keep_distance = self.target_height\\n #self.graph_distance = RollingGraph(window_name=\\\"Distance\\\", y_max=500, threshold=self.keep_distance, waitKey=False)\\n \\n if self.palm_landing_approach:\\n self.keep_distance = proximity\\n self.timestamp_keep_distance = time.time()\\n log.info(\\\"APPROACHING on pose\\\")\\n self.pid_pitch = PID(0.2,0.0,0.1,setpoint=0,output_limits=(-30,30))\\n #self.graph_distance = RollingGraph(window_name=\\\"Distance\\\", y_max=500, threshold=self.keep_distance, waitKey=False)\\n\\n self.body_in_prev_frame = True\\n \\n xoff = int(target[0]-ref_x)\\n yoff = int(ref_y-target[1])\\n\\n #We draw an arrow from the reference point to the head we are targeting \\n color = (0,0,255)\\n cv2.circle(frame, (ref_x, ref_y), 10, color, 1,cv2.LINE_AA)\\n cv2.line(frame, (ref_x, ref_y), target, color, 4)\\n cv2.rectangle(frame, (target[0]-target_width//2, target[1]-self.target_height//2), \\n (target[0]+target_width//2, target[1]+self.target_height//2),color,4)\\n \\n # The PID controllers calculate the new speeds for yaw and throttle\\n self.axis_speed[\\\"yaw\\\"] = int(-self.pid_yaw(xoff))\\n #log.debug(f\\\"xoff: {xoff} - speed_yaw: {self.axis_speed['yaw']}\\\")\\n self.last_rotation_is_cw = self.axis_speed[\\\"yaw\\\"] > 0\\n\\n self.axis_speed[\\\"throttle\\\"] = int(-self.pid_throttle(yoff))\\n #log.debug(f\\\"yoff: {yoff} - speed_throttle: {self.axis_speed['throttle']}\\\")\\n\\n #If in locked distance mode\\n if self.keep_distance and self.target_height: \\n \\n # Check RTH\\n if self.rth and self.target_height>=self.keep_distance:\\n self.rth = False\\n \\n elif self.palm_landing_approach and self.target_height>self.keep_distance:\\n # The drone is now close enough to the body\\n # Let's do the palm landing\\n log.info(\\\"PALM LANDING after approaching\\\")\\n self.palm_landing_approach = False\\n self.toggle_tracking(tracking=False)\\n self.palm_land() \\n \\n elif self.picture_approach and \\\\\\n abs(self.target_height-self.keep_distance) < 15 and \\\\\\n xoff < 12 and yoff < 15:\\n \\n # The drone is now close enough to the pic target\\n # Let's take a picture \\n self.toggle_tracking(tracking=False)\\n print('take a picture')\\n self.drone.take_picture()\\n self.picture_approach = False\\n self.timestamp_pic_target_found = None\\n self.pid_pitch = PID(0.3,0.0,0.1,setpoint=0,output_limits=(-70,70))\\n \\n \\n else:\\n self.axis_speed[\\\"pitch\\\"] = int(self.pid_pitch(self.target_height-self.keep_distance))\\n log.debug(f\\\"Target distance: {self.keep_distance} - cur: {self.target_height} -speed_pitch: {self.axis_speed['pitch']}\\\")\\n \\n if abs(head_pos[1] - hand_pos[1])<30:\\n if self.timestamp_hand_ctrl is None:\\n self.timestamp_hand_ctrl = time.time()\\n if time.time() - self.timestamp_hand_ctrl > 1:\\n if self.head_hand_x_dist is None:\\n self.head_hand_x_ref = head_pos[0]-hand_pos[0]\\n \\n self.hand_ctrl = True\\n self.head_hand_x_dist = head_pos[0]-hand_pos[0]\\n self.axis_speed[\\\"roll\\\"] = int(-self.pid_roll(self.head_hand_x_ref - self.head_hand_x_dist))\\n #print (f'head hand X distance: {abs(head_pos[0]-hand_pos[0])}')\\n\\n else:\\n self.hand_ctrl = False\\n self.timestamp_hand_ctrl = None\\n self.head_hand_x_dist = None\\n\\n else: # Tracking but no body detected\\n if self.body_in_prev_frame:\\n self.timestamp_no_body = time.time()\\n self.body_in_prev_frame = False\\n self.axis_speed[\\\"throttle\\\"] = self.prev_axis_speed[\\\"throttle\\\"]\\n self.axis_speed[\\\"yaw\\\"] = self.prev_axis_speed[\\\"yaw\\\"]\\n else:\\n if time.time() - self.timestamp_no_body < 1:\\n print(\\\"NO BODY SINCE < 1\\\", self.axis_speed, self.prev_axis_speed)\\n self.axis_speed[\\\"throttle\\\"] = self.prev_axis_speed[\\\"throttle\\\"]\\n self.axis_speed[\\\"yaw\\\"] = self.prev_axis_speed[\\\"yaw\\\"]\\n else:\\n log.debug(\\\"NO BODY detected for 1s -> rotate\\\")\\n self.axis_speed[\\\"yaw\\\"] = self.def_speed[\\\"yaw\\\"] * (1 if self.last_rotation_is_cw else -1)\\n \\n\\n # Send axis commands to the drone\\n for axis, command in self.axis_command.items():\\n if self.axis_speed[axis]is not None and self.axis_speed[axis] != self.prev_axis_speed[axis]:\\n #log.debug(f\\\"COMMAND {axis} : {self.axis_speed[axis]}\\\")\\n command(self.axis_speed[axis])\\n self.prev_axis_speed[axis] = self.axis_speed[axis]\\n else:\\n # This line is necessary to display current values in 'self.write_hud'\\n self.axis_speed[axis] = self.prev_axis_speed[axis]\\n \\n # Write the HUD on the frame\\n frame = self.write_hud(frame)\\n\\n return frame\",\n \"def generate_sphere_full():\\n \\n num_voxels = 31\\n c = (15.0, 15.0, 15.0)\\n\\n data_x = []\\n data_y = []\\n data_z = []\\n data_intensity = []\\n\\n volume = numpy.zeros((num_voxels, num_voxels, num_voxels))\\n\\n for x in range(num_voxels):\\n for y in range(num_voxels):\\n for z in range(num_voxels):\\n\\n if numpy.sqrt((x-c[0])**2 + (y-c[1])**2 + (z-c[2])**2) - 7.5 < 1.5:\\n data_x.append(x)\\n data_y.append(y)\\n data_z.append(z)\\n data_intensity.append(200.0)\\n\\n volume[x,y,z] = 200.0\\n\\n\\n return data_x, data_y, data_z, data_intensity, volume\",\n \"def FL_2_mav_gps(self, data):\\n\\n\\n\\n #Data treatment\\n messagedata = [\\n int(data['simulation/sim-time-sec']*self._sec2usec), #time_usec boot time usec int\\n 3, #Fix_type uint8_t\\t0-1: no fix, 2: 2D fix, 3: 3D fix. Some applications will not use the value of this field unless it is at least two, so always correctly fill in the fix.\\n int(data['position/lat-gc-rad']*self._rad2degE7), # lat 10e7.deg int\\n int(data['position/long-gc-rad']*self._rad2degE7), # lon 10e7.deg int\\n int(data['position/h-sl-ft']*self._ft2m*self._m2mm), # alt mm int\\n 65535, #eph uint16_t\\tGPS HDOP horizontal dilution of position in cm (m*100). If unknown, set to: 65535\\n 65535, #epv\\tuint16_t\\tGPS VDOP vertical dilution of position in cm (m*100). If unknown, set to: 65535\\n 65535, #uint16_t\\tGPS ground speed (m/s * 100). If unknown, set to: 65535\\n int(data['velocities/v-north-fps']*self._ft2m*self._m2cm),# vn cm.s-1 int\\n int(data['velocities/v-east-fps']*self._ft2m*self._m2cm), # ve cm.s-1 int\\n int(data['velocities/v-down-fps']*self._ft2m*self._m2cm), # vd cm.s-1 int\\n 65535, #cog\\tuint16_t\\tCourse over ground (NOT heading, but direction of movement) in degrees * 100, 0.0..359.99 degrees. If unknown, set to: 65535\\n 255, #satellites_visible\\tuint8_t\\tNumber of satellites visible. If unknown, set to 255\\n ]\\n\\n return messagedata\",\n \"def testCalspecMags(self):\\n std = MKIDStd.MKIDStd()\\n bFilter = std.filters['B']\\n vFilter = std.filters['V']\\n\\n # BD17\\n bd17Flux = std.load(\\\"bd17\\\")\\n B = std.getVegaMag(bd17Flux, bFilter)\\n V = std.getVegaMag(bd17Flux, vFilter)\\n self.assertAlmostEqual(B-V, 0.44, places=1, msg=\\\"value=%f\\\"%B)\\n self.assertAlmostEqual(B, 9.47, places=0, msg=\\\"value=%f\\\"%B)\",\n \"def Magnus4(self,direction='x'):\\n self.reset()\\n self.mol.orthoDen()\\n self.mol.orthoFock()\\n h = -1j*self.stepsize\\n for idx,time in enumerate((self.time)):\\n if direction.lower() == 'x':\\n self.mol.computeDipole()\\n self.dipole.append(np.real(self.mol.mu[0]))\\n elif direction.lower() == 'y':\\n self.mol.computeDipole()\\n self.dipole.append(np.real(self.mol.mu[1]))\\n elif direction.lower() == 'z':\\n self.mol.computeDipole()\\n self.dipole.append(np.real(self.mol.mu[2]))\\n # record pulse envelope for later plotting, etc.\\n self.shape.append(self.pulse(time))\\n curDen = np.copy(self.mol.PO)\\n \\n self.addField(time + 0.0*self.stepsize,direction=direction)\\n k1 = h*self.mol.FO \\n Q1 = k1\\n U = expm(0.5*Q1)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n \\n self.addField(time + 0.5*self.stepsize,direction=direction)\\n k2 = h*self.mol.FO\\n Q2 = k2 - k1\\n U = expm(0.5*Q1 + 0.25*Q2)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n\\n self.addField(time + 0.5*self.stepsize,direction=direction)\\n k3 = h*self.mol.FO\\n Q3 = k3 - k2\\n U = expm(Q1 + Q2)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n\\n self.addField(time + 1.0*self.stepsize,direction=direction)\\n k4 = h*self.mol.FO\\n Q4 = k4 - 2*k2 + k1\\n L = 0.5*Q1 + 0.25*Q2 + (1/3.)*Q3 - (1/24.)*Q4\\n L += -(1/48.)*self.mol.comm(Q1,Q2)\\n U = expm(L)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n \\n self.addField(time + 0.5*self.stepsize,direction=direction)\\n k5 = h*self.mol.FO\\n Q5 = k5 - k2 \\n L = Q1 + Q2 + (2/3.)*Q3 + (1/6.)*Q4 - (1/6.)*self.mol.comm(Q1,Q2)\\n U = expm(L)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n \\n self.addField(time + 1.0*self.stepsize,direction=direction)\\n k6 = h*self.mol.FO\\n Q6 = k6 -2*k2 + k1\\n L = Q1 + Q2 + (2/3.)*Q5 + (1/6.)*Q6\\n L += -(1/6.)*self.mol.comm(Q1, (Q2 - Q3 + Q5 + 0.5*Q6))\\n\\n U = expm(L)\\n self.mol.PO = np.dot(U,np.dot(curDen,self.mol.adj(U))) \\n self.mol.updateFock()\\n \\n # density and Fock are done updating, wrap things up\\n self.mol.unOrthoFock() \\n self.mol.unOrthoDen() \\n self.mol.computeEnergy()\\n self.Energy.append(np.real(self.mol.energy))\",\n \"def FL_2_mav_state(self, data):\\n\\n (data['velocities/phidot-rad_sec_bf'],\\n data['velocities/thetadot-rad_sec_bf'],\\n data['velocities/psidot-rad_sec_bf']) = self.convert_body_frame(\\n data['attitude/phi-rad'],\\n data['attitude/theta-rad'],\\n data['velocities/phidot-rad_sec'],\\n data['velocities/thetadot-rad_sec'],\\n data['velocities/psidot-rad_sec']\\n )\\n\\n # Data treatment\\n message_data = [\\n 1000000000,\\n # int(data['simulation/sim-time-sec']*cls._sec2usec), # time usec\\n data['attitude/phi-rad'], # phi rad float\\n data['attitude/theta-rad'], # theta rad float\\n data['attitude/psi-rad'], # psi rad float\\n data['velocities/phidot-rad_sec'], # rollspeed rad.s-1 float\\n data['velocities/thetadot-rad_sec'], # pitchspeed rad.s-1 float\\n data['velocities/psidot-rad_sec'], # yawspeed rad.s-1 float\\n int(data['position/lat-gc-rad']*self._rad2degE7), # lat 10e7.deg int\\n int(data['position/long-gc-rad']*self._rad2degE7), # lon 10e7.deg int\\n int(data['position/h-sl-ft']*self._ft2m*self._m2mm), # alt mm int\\n int(data['velocities/v-north-fps']*self._ft2m*self._m2cm), # vx cm.s-1 int\\n int(data['velocities/v-east-fps']*self._ft2m*self._m2cm), # vy cm.s-1 int\\n int(data['velocities/v-down-fps']*self._ft2m*self._m2cm), # vz cm.s-1 int\\n int(data['accelerations/udot-ft_sec2']*self._ft2m*self._mpss2mg), # xacc 1000/g int\\n int(data['accelerations/vdot-ft_sec2']*self._ft2m*self._mpss2mg), # yacc 1000/g int\\n int(data['accelerations/wdot-ft_sec2']*self._ft2m*self._mpss2mg) # zacc 1000/g int\\n ]\\n return message_data\",\n \"def Motion_estimate_compute_1frame(ref1_frame,ref2_frame,target_frame,block_size):\\n\\n ref_Y, ref_U, ref_V = [], [], []\\n for ref_frame in [ref1_frame,ref2_frame]:\\n ref_Y.append(np.array(ref_frame[ :sep1]).reshape(height,width))\\n ref_U.append(np.array(ref_frame[sep1:sep2]).reshape(height//2,width//2))\\n ref_V.append(np.array(ref_frame[sep2: ]).reshape(height//2,width//2))\\n \\n tar_Y = target_frame[ :sep1].reshape(height,width)\\n tar_U = target_frame[sep1:sep2].reshape(height//2,width//2)\\n tar_V = target_frame[sep2: ].reshape(height//2,width//2)\\n \\n err_Y = np.array(tar_Y)\\n err_U = np.array(tar_U)\\n err_V = np.array(tar_V)\\n vect_field = np.zeros((height//block_size,width//block_size,3),dtype=int)\\n \\n for X in range(0,height//block_size):\\n for Y in range(0,width//block_size):\\n xa, xz = X*block_size,(X+1)*block_size\\n ya, yz = Y*block_size,(Y+1)*block_size\\n # Find the motion vector for the block XY\\n \\n ref,vx,vy = Motion_estimate_compute_P_1block(ref_Y[0],ref_Y[1],\\n tar_Y[xa:xz,ya:yz],\\n [xa,ya])\\n \\n vect_field[X,Y,:] = np.array([ref,vx,vy])\\n \\n pxa, pxz = xa+vx,xz+vx\\n pya, pyz = ya+vy,yz+vy\\n \\n patch_Y = ref_Y[ref][pxa:pxz,pya:pyz]\\n patch_U = ref_U[ref][pxa//2:pxz//2,pya//2:pyz//2]\\n patch_V = ref_V[ref][pxa//2:pxz//2,pya//2:pyz//2]\\n \\n err_Y[xa:xz,ya:yz] -= patch_Y\\n err_U[xa//2:xz//2,ya//2:yz//2] -= patch_U\\n err_V[xa//2:xz//2,ya//2:yz//2] -= patch_V\\n \\n frame_error = np.concatenate((err_Y.flatten(),\\n err_U.flatten(),\\n err_V.flatten()))\\n dct_error = DCT_compute(frame_error,offset=0,Q='opti') # Error -> mean = 0\\n # -> offset =0\\n \\n P_frame = np.concatenate((vect_field.flatten(),dct_error.flatten()))\\n \\n return P_frame\",\n \"def blockDetector(self, frame):\\n self.detectBlocksInDepthImage()\\n self.block_pos = np.zeros((50,3))\\n self.block_num = 0\\n pixal_arm = np.zeros(2)\\n if self.kinectCalibrated == True:\\n # get current arm position\\n real_arm_x, real_arm_y,_,_ = self.rexarm.get_wrist_pose()\\n real_arm_x *= -1000\\n real_arm_y *= 1000\\n real_arm = np.array(([real_arm_x],[real_arm_y],[1]))\\n \\n # normalize arm_line vector\\n arm_length = np.sqrt(real_arm_x**2 + real_arm_y**2)\\n l = np.array([real_arm_x,real_arm_y])\\n\\n # find center of block_1_height and put them into block_position\\n for cnt in self.block_contours:\\n M = cv2.moments(cnt)\\n if M['m00']>0:\\n cx = int(M['m10']/M['m00'])\\n cy = int(M['m01']/M['m00'])\\n c = np.array([[cx],[cy]])\\n # Eliminate Arm itself\\n real_x = self.real_coord[cx][cy][0]\\n real_y = self.real_coord[cx][cy][1]\\n d = np.linalg.norm(np.cross(l, np.array([real_x,real_y])))/np.linalg.norm(l)\\n \\n d_to_arm = np.sqrt((real_x-real_arm_x)**2+(real_y-real_arm_y)**2)\\n d_to_ori = np.sqrt(real_x**2 + real_y**2)\\n\\n \\n if d > 2 and not(d_to_ori<arm_length and d_to_arm<arm_length):\\n # Check if its in our ROI\\n if self.real_coord[cx][cy][0]>self.real_points[0][0] and self.real_coord[cx][cy][0]<self.real_points[2][0]:\\n if self.real_coord[cx][cy][1]<self.real_points[0][1] and self.real_coord[cx][cy][1]>self.real_points[2][1]:\\n # points\\n self.block_pos[self.block_num][0] = self.real_coord[cx][cy][0]\\n self.block_pos[self.block_num][1] = self.real_coord[cx][cy][1]\\n self.block_pos[self.block_num][2] = 1\\n # orientation\\n rect = cv2.minAreaRect(cnt)\\n self.block_ori[self.block_num][0] = -rect[2]\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n # detect color\\n self.block_color[self.block_num] = self.colorDetector(cx,cy)\\n # draw contours\\n cv2.drawContours(self.currentDetectFrame,[box],0,(30,145,86),3)\\n cv2.circle(self.currentDetectFrame,(cx,cy),5,(30,145,86),-1)\\n self.block_num += 1\\n\\n # find centers of 2 blocks\\n for cnt in self.block_contours_2:\\n M = cv2.moments(cnt)\\n if M['m00']>0:\\n cx = int(M['m10']/M['m00'])\\n cy = int(M['m01']/M['m00'])\\n c = np.array([[cx],[cy]])\\n # Eliminate Arm itself\\n real_x = self.real_coord[cx][cy][0]\\n real_y = self.real_coord[cx][cy][1]\\n d = np.linalg.norm(np.cross(l, np.array([real_x,real_y])))/np.linalg.norm(l)\\n \\n d_to_arm = np.sqrt((real_x-real_arm_x)**2+(real_y-real_arm_y)**2)\\n d_to_ori = np.sqrt(real_x**2 + real_y**2)\\n \\n \\n if d > 2 and not(d_to_ori<arm_length and d_to_arm<arm_length):\\n # Check if its in our ROI\\n if self.real_coord[cx][cy][0]>self.real_points[0][0] and self.real_coord[cx][cy][0]<self.real_points[2][0]:\\n if self.real_coord[cx][cy][1]<self.real_points[0][1] and self.real_coord[cx][cy][1]>self.real_points[2][1]:\\n # points\\n self.block_pos[self.block_num][0] = self.real_coord[cx][cy][0]\\n self.block_pos[self.block_num][1] = self.real_coord[cx][cy][1]\\n self.block_pos[self.block_num][2] = 2\\n # orientation\\n rect = cv2.minAreaRect(cnt)\\n self.block_ori[self.block_num][0] = -rect[2]\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n # detect color\\n self.block_color[self.block_num] = self.colorDetector(cx,cy)\\n # draw contours\\n cv2.drawContours(self.currentDetectFrame,[box],0,(30,87,137),3)\\n cv2.circle(self.currentDetectFrame,(cx,cy),5,(30,87,137),-1)\\n self.block_num += 1 \\n\\n # find centers of 3 blocks\\n for cnt in self.block_contours_3:\\n M = cv2.moments(cnt)\\n if M['m00']>0:\\n cx = int(M['m10']/M['m00'])\\n cy = int(M['m01']/M['m00'])\\n c = np.array([[cx],[cy]])\\n # Eliminate Arm itself\\n real_x = self.real_coord[cx][cy][0]\\n real_y = self.real_coord[cx][cy][1]\\n d = np.linalg.norm(np.cross(l, np.array([real_x,real_y])))/np.linalg.norm(l)\\n \\n d_to_arm = np.sqrt((real_x-real_arm_x)**2+(real_y-real_arm_y)**2)\\n d_to_ori = np.sqrt(real_x**2 + real_y**2)\\n \\n \\n if d > 2 and not(d_to_ori<arm_length and d_to_arm<arm_length):\\n # Check if its in our ROI\\n if self.real_coord[cx][cy][0]>self.real_points[0][0] and self.real_coord[cx][cy][0]<self.real_points[2][0]:\\n if self.real_coord[cx][cy][1]<self.real_points[0][1] and self.real_coord[cx][cy][1]>self.real_points[2][1]:\\n # points\\n self.block_pos[self.block_num][0] = self.real_coord[cx][cy][0]\\n self.block_pos[self.block_num][1] = self.real_coord[cx][cy][1]\\n self.block_pos[self.block_num][2] = 3\\n # orientation\\n rect = cv2.minAreaRect(cnt)\\n self.block_ori[self.block_num][0] = -rect[2]\\n box = cv2.boxPoints(rect)\\n box = np.int0(box)\\n # detect color\\n self.block_color[self.block_num] = self.colorDetector(cx,cy)\\n # draw contours\\n cv2.drawContours(self.currentDetectFrame,[box],0,(204,6,6),3)\\n cv2.circle(self.currentDetectFrame,(cx,cy),5,(204,6,6),-1)\\n self.block_num += 1 \\n self.block_pos[self.block_num:50] = 0\\n self.block_ori[self.block_num:50] = 0\\n\\n return frame\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63979864","0.58925015","0.5888225","0.5737547","0.56940204","0.566803","0.5652638","0.561245","0.56079805","0.5605385","0.56043845","0.5591721","0.5587432","0.55768406","0.55294365","0.5511706","0.55075437","0.54954225","0.5465866","0.54398566","0.54375684","0.54347444","0.5431534","0.5423789","0.5380655","0.5368338","0.53501314","0.5334669","0.53345025","0.5323652","0.5322486","0.53202355","0.53113407","0.53039485","0.5280621","0.5276593","0.52648944","0.5250815","0.5247732","0.5234314","0.52266586","0.5194335","0.51836896","0.51835227","0.51830834","0.5179631","0.51665825","0.51613384","0.5155498","0.5140816","0.5127165","0.5118334","0.5116746","0.5114937","0.5109435","0.50945944","0.50899214","0.50831866","0.5076234","0.5069768","0.5069482","0.5065817","0.50542915","0.505281","0.5052499","0.50310445","0.5029029","0.50243413","0.5013305","0.50057626","0.5000973","0.49983802","0.49965146","0.4993291","0.49883547","0.49851146","0.49811047","0.49774873","0.4972095","0.49702963","0.49700364","0.49589413","0.49534282","0.49532557","0.49492636","0.4942821","0.4941219","0.49397722","0.493364","0.49282986","0.49255416","0.49175966","0.49165493","0.49117082","0.4909196","0.4908916","0.4907463","0.4906595","0.4903363","0.48972368"],"string":"[\n \"0.63979864\",\n \"0.58925015\",\n \"0.5888225\",\n \"0.5737547\",\n \"0.56940204\",\n \"0.566803\",\n \"0.5652638\",\n \"0.561245\",\n \"0.56079805\",\n \"0.5605385\",\n \"0.56043845\",\n \"0.5591721\",\n \"0.5587432\",\n \"0.55768406\",\n \"0.55294365\",\n \"0.5511706\",\n \"0.55075437\",\n \"0.54954225\",\n \"0.5465866\",\n \"0.54398566\",\n \"0.54375684\",\n \"0.54347444\",\n \"0.5431534\",\n \"0.5423789\",\n \"0.5380655\",\n \"0.5368338\",\n \"0.53501314\",\n \"0.5334669\",\n \"0.53345025\",\n \"0.5323652\",\n \"0.5322486\",\n \"0.53202355\",\n \"0.53113407\",\n \"0.53039485\",\n \"0.5280621\",\n \"0.5276593\",\n \"0.52648944\",\n \"0.5250815\",\n \"0.5247732\",\n \"0.5234314\",\n \"0.52266586\",\n \"0.5194335\",\n \"0.51836896\",\n \"0.51835227\",\n \"0.51830834\",\n \"0.5179631\",\n \"0.51665825\",\n \"0.51613384\",\n \"0.5155498\",\n \"0.5140816\",\n \"0.5127165\",\n \"0.5118334\",\n \"0.5116746\",\n \"0.5114937\",\n \"0.5109435\",\n \"0.50945944\",\n \"0.50899214\",\n \"0.50831866\",\n \"0.5076234\",\n \"0.5069768\",\n \"0.5069482\",\n \"0.5065817\",\n \"0.50542915\",\n \"0.505281\",\n \"0.5052499\",\n \"0.50310445\",\n \"0.5029029\",\n \"0.50243413\",\n \"0.5013305\",\n \"0.50057626\",\n \"0.5000973\",\n \"0.49983802\",\n \"0.49965146\",\n \"0.4993291\",\n \"0.49883547\",\n \"0.49851146\",\n \"0.49811047\",\n \"0.49774873\",\n \"0.4972095\",\n \"0.49702963\",\n \"0.49700364\",\n \"0.49589413\",\n \"0.49534282\",\n \"0.49532557\",\n \"0.49492636\",\n \"0.4942821\",\n \"0.4941219\",\n \"0.49397722\",\n \"0.493364\",\n \"0.49282986\",\n \"0.49255416\",\n \"0.49175966\",\n \"0.49165493\",\n \"0.49117082\",\n \"0.4909196\",\n \"0.4908916\",\n \"0.4907463\",\n \"0.4906595\",\n \"0.4903363\",\n \"0.48972368\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.51907223"},"document_rank":{"kind":"string","value":"42"}}},{"rowIdx":23196,"cells":{"query":{"kind":"string","value":"More precise than plotting becuase it doens't have to thin the times For every shot, find the calibration value, then average it"},"document":{"kind":"string","value":"def generatelookup(num_probes = 16):\n calibration_lookup= [[0] * 3 for i in range(num_probes)]\n # print(calibration_lookup)\n day = '050119r'\n date = '050119'\n\n def _run_calib(shots, dir):\n \"\"\" Helper function \"\"\"\n for shot in shots:\n shot = day+str(shot)\n ratios = ratio_4_doc(shot, dir)\n for i in range(num_probes):\n calibration_lookup[i][dir] = calibration_lookup[i][dir] + ratios[i][dir]\n if shot == shots[-1]: #on the last shot, divide by the number of shots\n calibration_lookup[i][dir] = calibration_lookup[i][dir]/ len(shots)\n\n # shot = day+str(13)\n # ratios = ratio_4_doc(shot, 2)\n # time,eastcurrent,westcurrent = loadcurrent(shot)#u\n # plt.plot(time, eastcurrent, label = 'current')\n #\n # plt.show()\n # print(\"And the max current is %f\" %polyPeak_noPlot(time,eastcurrent))\n # #check if cm or m\n # r = get_probeLocs_calib_setup(shot)\n # print(\"r is:\", r[1])\n # print(ratios)\n #\n #\n # X - direction\n print(\"Generating X - dir\")\n shots = np.arange(17,21)\n _run_calib(shots, 0)\n\n\n # Y - direction\n print(\"Generating Y - dir\")\n shots = np.arange(21,26)\n _run_calib(shots, 1)\n\n print(\"Generating Z - dir\")\n # Z - direction\n shots = np.arange(11,16)\n _run_calib(shots, 2)\n\n\n pth = os.getcwd()\n print(\"Finished! File saved as calib-%s-4x4_lookup_5.txt in cwd\" %(date))\n savetxt(os.path.join(pth, 'calib-%s-4x4_lookup_5.txt' % (date)) , calibration_lookup)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def photometric_calibration():\n pass","def calibration(self) -> int:","def doRun(run=77):\n r = xanes_analyzeRun.AnalyzeRun(run)\n r.load()\n calibs = list(r.results.keys())\n calibs.sort()\n p2 = [np.nanmedian(r.results[c].p1, axis=0) for c in calibs]\n p2 = np.asarray(p2)\n ref = np.nanmedian(p2, axis=0)\n # normalize p2\n p2 = p2 / ref\n # remove non-flat part\n _x = np.arange(p2.shape[1], dtype=float)\n p2 = [s - mc.poly_approximant(_x, s, order=20)(_x) for s in p2]\n p2 = np.asarray(p2)\n x = np.asarray([_x for _ in p2])\n x[p2 > -0.15] = np.nan\n x[x < 100] = np.nan\n # below pixel 200 is noise\n pos = np.nanmean(x, axis=1)\n fig, ax = plt.subplots(1, 2, sharey=True)\n xshift = 0.2\n pcalib = []\n for icalib, (xi, p2i) in enumerate(zip(x, p2)):\n ppar = dict(color=myc(icalib))\n ax[0].plot(p2i + icalib * xshift, _x, \"--\", lw=1, alpha=0.5, **ppar)\n ax[0].plot(p2i + icalib * xshift, xi, lw=2, **ppar)\n pcalib.append(np.nanmedian(xi))\n ax[1].plot(r.scanpos[icalib], pcalib[icalib], \"o\", **ppar)\n polycal = np.polyfit(pcalib, r.scanpos, 1)\n ax[1].plot(np.polyval(polycal, _x), _x)\n print(\"polynomial calibration\", polycal)","def take_one_averaged(self):\n self.na.set_center_frequency(6.160574e9)\n self.na.set_span(10e6)\n self.na.set_power(-5, 1)\n self.na.set_ifbw(1e3)\n\n self.na.set_query_timeout(40e3)\n set_format = self.na.set_format('polar')\n print \"set_format returned: \", set_format\n self.na.set_trigger_source(\"manual\")\n self.na.set_averages(10)\n self.na.set_trigger_average_mode()\n\n self.na.clear_averages(channel=1)\n self.na.trigger_single(channel=1)\n fpts, xs, ys = self.na.read_data()\n #\n plt.figure()\n plt.plot(fpts, xs)\n plt.plot(fpts, ys)\n plt.show()","def calibration(self, cal: int, /) -> None:","def area_stats(self):\r\n x0 = self.ui.x0.value()\r\n x1 = self.ui.x1.value()\r\n y0 = self.ui.y0.value()\r\n y1 = self.ui.y1.value()\r\n \r\n channel = self.ui.channel_selection.itemData(self.ui.channel_selection.currentIndex())\r\n\r\n avg = np.average(self.npImg[y0:y1,x0:x1,channel])\r\n std = np.std(self.npImg[y0:y1,x0:x1,channel])\r\n minimum = np.min(self.npImg[y0:y1,x0:x1,channel])\r\n maximum = np.max(self.npImg[y0:y1,x0:x1,channel])\r\n \r\n n = (max(x1,x0)-min(x1,x0))*(max(y1,y0)-min(y1,y0))\r\n\r\n \r\n logging.info(\"### Statistics for area x: {:d} - {:d}; y: {:d} - {:d} ###\".format(x0,x1,y0,y1))\r\n logging.info(\"channel: {!s}\".format(self.ui.channel_selection.currentText()))\r\n logging.info(\"average: {:.3f} +- {:.3f}\".format(avg,std/np.sqrt(n)))\r\n logging.info(\"standard deviation: {:.3f}\".format(std))\r\n logging.info(\"maximum: {:d}\".format(maximum)) \r\n logging.info(\"minimum: {:d}\".format(minimum))\r\n logging.info(\"--------------------------------------------------------------\")","def calibrate(self):\n\t\tLTOGRIGHT = []\n\t\tLTOGUP = []\n\t\tRTOGRIGHT = []\n\t\tRTOGUP = []\n\t\tstart = time.time()\n\t\tcalibration_time = 5.0\n\t\twhile time.time() - start < calibration_time:\n\t\t\tevents = pygame.event.get()\n\t\t\tfor event in events:\n\t\t\t\tif event.type == pygame.JOYAXISMOTION:\n\t\t\t\t\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\n\t\t\t\t\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\n\t\t\t\t\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\n\t\t\t\t\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\n\n\t\t# calibration sets highest value equal to 1.0\n\t\tself.calibration[0] = 1.0/max(LTOGRIGHT)\n\t\tself.calibration[1] = -1.0/min(LTOGRIGHT)\n\t\tself.calibration[2] = -1.0/min(LTOGUP)\n\t\tself.calibration[3] = 1.0/max(LTOGUP)\n\t\tself.calibration[4] = 1.0/max(RTOGRIGHT)\n\t\tself.calibration[5] = -1.0/min(RTOGRIGHT)\n\t\tself.calibration[6] = -1.0/min(RTOGUP)\n\t\tself.calibration[7] = 1.0/max(RTOGUP)","def average_ps(self):\n\n self.powerspectrum=np.average(self.powerspectra, axis=0)","def average( names):\n\n rs = radioastronomy.Spectrum() # create input and average structures\n asum = radioastronomy.Spectrum()\n nsum = 0\n\n # now average coldest data for calibration\n for filename in names:\n\n rs.read_spec_ast(filename)\n rs.azel2radec() # compute ra,dec from az,el\n\n if nsum == 0:\n asum = copy.deepcopy( rs)\n firstlon = rs.gallon\n asum.ydataA = rs.ydataA * rs.durationSec\n asum.gallat = rs.gallat * rs.durationSec\n asum.gallon = rs.gallon * rs.durationSec\n nsum = 1\n firstutc = rs.utc\n lastutc = rs.utc\n else:\n asum.ydataA = asum.ydataA + (rs.ydataA * rs.durationSec)\n asum.count = asum.count + rs.count\n asum.durationSec = asum.durationSec + rs.durationSec\n # fix wrap of longitudes\n if abs(rs.gallon - firstlon) > 180:\n crossZero = True\n if rs.gallon > firstlon:\n rs.gallon = rs.gallon - 360.\n else:\n rs.gallon = rs.gallon + 360.\n asum.gallon = asum.gallon + (rs.gallon * rs.durationSec)\n asum.gallat = asum.gallat + (rs.gallat * rs.durationSec)\n # keep track of observing time for weighted sum\n lastutc = rs.utc\n nsum = nsum + 1\n #end for all files loop\n\n if nsum < 1:\n print \"No acceptable files in average list\"\n else:\n asum.ydataA = asum.ydataA/float(asum.durationSec)\n asum.gallon = asum.gallon/float(asum.durationSec)\n asum.gallat = asum.gallat/float(asum.durationSec)\n aveutc,duration = radioastronomy.aveutcs( firstutc, lastutc)\n asum.utc = aveutc\n if (duration < 1.):\n print 'hotcold.average: very short average interval: ',duration\n return nsum, asum","def ratio_4_doc(shot, dir, num_probes = 16):\n # data = [[0] *3 for i in range(num_probes)]\n # magdata = hdr.getMagData(shot)\n probe_locs = get_probeLocs_calib_setup(shot)\n data=hdr.getquikData(shot)\n time,eastcurrent,westcurrent = loadcurrent(shot)#using eastcurrent\n ratios = [[0]*3 for i in range(num_probes)]\n for probe in range(num_probes):\n ratio =1\n inverted = False\n # fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True)\n B=sp.signal.detrend(cumtrapz(data.unCalibData[dir,probe,:], data.time))\n plot_time = data.time[:-1]\n if(np.max(B[2000:6000]) < abs(np.average(B[2000:6000]))):\n # print(\"\\ninverted!\")\n inverted = True\n # B = B* -1\n # ratio = -1\n\n r = probe_locs[probe]\n max_current = polyPeak_noPlot(time,eastcurrent)\n # if(np.max(eastcurrent) < -1*(np.min(eastcurrent))):\n # max_current = -1*np.min(eastcurrent)\n helmB = helmholtz2(r,max_current)\n\n # THis is intentional! I am only using shots where the cmponent is lined\n # up with the z-direction of the helmholz field\n # helmB[2] = helmB[2]*-1\n max_theoretical = np.max(helmB[2])\n max_measured = polyPeak_noPlot(plot_time, B)\n\n\n ratio = ratio * max_theoretical/max_measured\n if ratio > 30000 or ratio < -30000:\n ratio = 0\n\n\n ratios[probe][dir] = ratio\n # print(\"\\tRatio is: %f\" %(ratio))\n # if(inverted and ratio <0):\n # print(\"Inverted and ratio reflects that\")\n # elif(not inverted and ratio <0):\n if probe ==1:\n print(\"\\n Ratio: %5f \\n\\t max_measured: %3f, \\n\\t max_theoretical: %5f\"%(ratio,max_measured,max_theoretical ) )\n\n # Compute the median of the non-zero elements\n # m = np.median(foo[foo > 0])\n # Assign the median to the zero elements\n # foo[foo == 0] = m\n return ratios","def applyCal(beam, row, freqs, freqs_cal, cf, T_d_x, T_d_y):\n \n P_sys_xx = beam.cols.xx[row].astype('float')\n xx_on = beam.cols.xx_cal_on[row].astype('float')\n xx_off = beam.cols.xx_cal_off[row].astype('float')\n P_on_xx = np.average(extractMid(xx_on))\n P_off_xx = np.average(extractMid(xx_off))\n \n #P_on_xx = fitLine(freqs_cal, xx_on, len(freqs))\n #P_off_xx = fitLine(freqs_cal, xx_off, len(freqs))\n\n P_sys_yy = beam.cols.yy[row].astype('float')\n yy_on = beam.cols.yy_cal_on[row].astype('float')\n yy_off = beam.cols.yy_cal_off[row].astype('float')\n P_on_yy = np.average(extractMid(yy_on))\n P_off_yy = np.average(extractMid(yy_off))\n \n #P_on_yy = fitLine(freqs_cal, yy_on, len(freqs))\n #P_off_yy = fitLine(freqs_cal, yy_off, len(freqs))\n\n \n T_sys_xx = P_sys_xx / (cf*P_on_xx - cf*P_off_xx) * T_d_x\n T_sys_yy = P_sys_yy / (cf*P_on_yy - cf*P_off_yy) * T_d_y\n \n return T_sys_xx, T_sys_yy","def aperture_phot(self,data,x,y,v):\n r = np.sqrt((x-self.avg_map_fits['Values'][1])**2 + (y-self.avg_map_fits['Values'][3])**2)\n \n inner = (r < 8./60.) & np.isfinite(data) \n outer = (r > 8.5/60.) & (r < 12./60.) & np.isfinite(data)\n\n annu = np.nanmedian(data[outer])\n annu_rms = np.nanstd(data[outer])\n flux = np.sum(data[inner]) - annu*np.sum(inner)\n\n c = 3e8\n kb=1.38e-23\n beam = (1./60.*np.pi/180.)**2\n factor = 2*kb*(v*1e9/c)**2 * beam * 1e26\n return flux*factor, annu_rms*np.sqrt(np.sum(inner))*factor","def average(self, times=2):\n for i in range(times):\n self.statistics()\n global t, avlist\n length = len(t)\n avlist.append(t)\n t = []\n\n total_list = []\n\n for l in range(length):\n total_list.append([])\n\n for j in range(times):\n \"\"\"per time\"\"\"\n for i in range(length):\n total_list[i].append(avlist[j][i])\n\n \"\"\"calculate\"\"\"\n ylist = []\n avlist = []\n for a in total_list:\n avg = 0\n for b in a:\n avg += b\n ylist.append(avg/times)\n self.listy = ylist\n\n for e in range(self.el[self.re[0]], self.re[1], self.re[2]):\n self.listx.append(e)","def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\n ratio_x = 0\n ratio_y = 0\n ratio_z = 0\n # helm_B = [0,0,0]\n divideby = 0\n for shot in range(shot_range[0], shot_range[1]+1):\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\n ratio_x = ratio_x + x\n ratio_y = ratio_y + y\n ratio_z = ratio_z + z\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\n divideby = divideby + 1 #averaging over the number of shots\n ratio_Bx = ratio_x/divideby\n ratio_By = ratio_y/divideby\n ratio_Bz = ratio_z/divideby\n # helmB = [helm_B]/divideby\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\n # print(\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\n Bx_sqr =ratio_x**2\n By_sqr =ratio_y**2\n Bz_sqr =ratio_z**2\n B = Bx_sqr + By_sqr+ Bz_sqr\n norm_factor = np.sqrt(B)\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\n\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)","def getavgvel(self):\n if self.total_time:\n return (6.28)/(self.total_time)","def test_plot_average(self):\n # Unpack the list of baseline-pairs into a Python list\n blpairs = np.unique(self.uvp.blpair_array)\n blps = [blp for blp in blpairs]\n\n # Plot the spectra averaged over baseline-pairs and times\n f1 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\n average_blpairs=True, average_times=True)\n elements = [(matplotlib.lines.Line2D, 1),]\n assert axes_contains(f1.axes[0], elements)\n plt.close(f1)\n\n # Average over baseline-pairs but keep the time bins intact\n f2 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\n average_blpairs=True, average_times=False)\n elements = [(matplotlib.lines.Line2D, self.uvp.Ntpairs),]\n assert axes_contains(f2.axes[0], elements)\n plt.close(f2)\n\n # Average over times, but keep the baseline-pairs separate\n f3 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\n average_blpairs=False, average_times=True)\n elements = [(matplotlib.lines.Line2D, self.uvp.Nblpairs),]\n assert axes_contains(f3.axes[0], elements)\n plt.close(f3)\n\n # Plot the spectra averaged over baseline-pairs and times, but also\n # fold the delay axis\n f4 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\n average_blpairs=True, average_times=True,\n fold=True)\n elements = [(matplotlib.lines.Line2D, 1),]\n assert axes_contains(f4.axes[0], elements)\n plt.close(f4)\n\n # Plot imaginary part\n f4 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\n average_blpairs=False, average_times=True,\n component='imag')\n elements = [(matplotlib.lines.Line2D, self.uvp.Nblpairs),]\n assert axes_contains(f4.axes[0], elements)\n plt.close(f4)\n\n # Plot abs\n f5 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\n average_blpairs=False, average_times=True,\n component='abs')\n elements = [(matplotlib.lines.Line2D, self.uvp.Nblpairs),]\n assert axes_contains(f4.axes[0], elements)\n plt.close(f5)\n\n # test errorbar plotting w/ markers\n\n # bootstrap resample\n (uvp_avg, _,\n _) = grouping.bootstrap_resampled_error(self.uvp, time_avg=True,\n Nsamples=100, normal_std=True,\n robust_std=False, verbose=False)\n\n f6 = plot.delay_spectrum(uvp_avg, uvp_avg.get_blpairs(), spw=0,\n pol=('xx','xx'), average_blpairs=False,\n average_times=False,\n component='real', error='bs_std', lines=False,\n markers=True)\n plt.close(f6)\n\n # plot errorbar instead of pspec\n f7 = plot.delay_spectrum(uvp_avg, uvp_avg.get_blpairs(), spw=0,\n pol=('xx','xx'), average_blpairs=False,\n average_times=False,\n component='real', lines=False,\n markers=True, plot_stats='bs_std')\n plt.close(f7)","def baseline(spectra):\n\n return spectra - np.mean(spectra, axis=0)","def analysis_dFF_map(self):\r\n\r\n \r\n\r\n print ('Starting dF/F analysis:')\r\n\r\n self.print_image_info()\r\n\r\n # smoothwin = int(self.imageData.shape[1]/8.)\r\n\r\n # get the average image and the average of the whole image over time\r\n\r\n avgimg = np.mean(self.imageData, axis=0) # get mean image for reference later: average across all time\r\n\r\n \r\n\r\n mpl.figure(99)\r\n\r\n mpl.imshow(avgimg, vmin=0, vmax=np.max(np.max(avgimg, axis=0), axis=0))\r\n\r\n # self.meanimagevalue = np.mean(np.mean(avgimg, axis=1), axis=0)\r\n\r\n # self.stdimg = np.std(self.imageData, axis= 0) # and standard deviation\r\n\r\n imgdatasm = scipy.ndimage.filters.gaussian_filter(self.imageData,[0,2,2],order=0,output=None,mode='reflect',cval=0.0,truncate=4.0)\r\n # field correction: smooth the average image, subtract it from the imagedata, then add back the mean value\r\n avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, 2, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n # avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n #self.imageData = (self.imageData-avgimgsm)+ self.meanimagevalue\r\n\r\n mpl.figure(98)\r\n mpl.imshow(avgimgsm,vmin=0, vmax=np.max(np.max(avgimgsm, axis=0), axis=0))\r\n mpl.figure(97)\r\n mpl.imshow(np.mean(imgdatasm,axis=0))\r\n self.n_times = self.timebase\r\n\r\n periodsize = int(self.period*self.framerate)\r\n print('periodsize: ',periodsize)\r\n\r\n # windowsize = int(self.freqperiod*self.framerate) # window size for every response\r\n\r\n # r = range(0, self.imageData.shape[0], windowsize)\r\n\r\n sig = np.reshape(imgdatasm, (self.nrepetitions, periodsize, \r\n\r\n self.imageData.shape[1], self.imageData.shape[2]), order='C')\r\n\r\n delresp=np.zeros([19,256,256])\r\n repback = np.mean(sig[:,1:4,:,:],axis=1)\r\n resp = np.mean(sig[:,5:9,:,:],axis=1)\r\n for counter in range(19):\r\n delresp[counter,:,:]=(resp[counter,:,:]-repback[counter,:,:])/repback[counter,:,:]\r\n quot=np.mean(delresp,axis=0)\r\n quot=-quot\r\n print ('shape of quot: ', np.shape(quot))\r\n # quot=(resp-repback)/repback\r\n # quot[quot>0]=0\r\n # quot=-1000*quot\r\n\r\n mpl.figure(7)\r\n mpl.imshow(quot,cmap=mpl.cm.binary)\r\n mpl.colorbar()\r\n\r\n quotsm = scipy.ndimage.filters.gaussian_filter(quot, 3, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n mpl.figure(8)\r\n mpl.imshow(quotsm,cmap=mpl.cm.binary)\r\n mpl.colorbar()\r\n \r\n # bl = np.mean(sig[:, range(0, sig.shape[1], windowsize), :, :], axis=0)\r\n\r\n # bl = scipy.ndimage.filters.gaussian_filter(bl, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n\r\n\r\n # print (' windowsize: ', windowsize)\r\n\r\n # print (' periodsize: ', periodsize)\r\n # mc = matplotlib.cm\r\n\r\n # only use sequential maps here\r\n\r\n # clist = [mc.Reds, mc.YlOrBr, mc.Oranges, mc.Greens, mc.GnBu, mc.Blues, mc.RdPu, mc.Purples,mc.Reds,mc.Greens,mc.Blues,mc.Reds,mc.Reds,mc.Reds,mc.Reds]\r\n # clist2 = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'black','red','purple','green','blue','red','red','red','red']\r\n\r\n cs = {}\r\n\r\n # sigd = np.zeros((bl.shape[0], sig.shape[2], sig.shape[3]))\r\n# \r\n # localmax = {}\r\n\r\n # sigmax = 0.\r\n# \r\n # kernel = np.ones((5, 5))\r\n\r\n # psf = kernel / np.sum(kernel)\r\n\r\n # compute dF/F, and get maximum over all frequencies\r\n\r\n print (' sig shape: ', sig.shape)\r\n\r\n # print (' bl shape: ', bl.shape)\r\n\r\n # smax = np.zeros(bl.shape[0])\r\n\r\n # for i in range(bl.shape[0]):\r\n\r\n # sigd[i] = (np.mean(np.max(sig[:,range(i*windowsize, i*windowsize+windowsize),:,:], axis=0), axis=0) - bl[i,:,:])/bl[i,:,:]\r\n\r\n # sigd[i] = sigd[i]**2.0\r\n\r\n # smooth\r\n\r\n #sigd[i] = scipy.ndimage.filters.gaussian_filter(sigd[i], 1., order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\r\n\r\n # deconvolve\r\n\r\n # sigd[i] = restoration.richardson_lucy(sigd[i], psf, 5)\r\n\r\n# sm = sigd[i].max().max()\r\n\r\n# if sm > sigmax:\r\n\r\n# sigmax = sm\r\n\r\n# smax[i] = sm\r\n\r\n# print( ' i, sm: ', i, sm)\r\n\r\n# # now process for display\r\n\r\n# print (' sigd shape: ', sigd.shape)\r\n\r\n# wdat = np.mean(sig, axis=0)\r\n\r\n# wds = wdat.shape\r\n\r\n# print('wdat shape: ', wds)\r\n\r\n# # print (range(int(wds[1]/2.), int(3.*wds[1]/4.)), range(int(wds[2]/2.), int(3.*wds[2]/4.)))\r\n\r\n# print( 'reduced shape: ', wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))].shape)\r\n\r\n# wp = wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))]\r\n\r\n# wp = np.mean(np.mean(wdat, axis=1), axis=1)\r\n\r\n# mpl.figure(1)\r\n\r\n# mpl.plot(np.linspace(0., len(wp)*1./self.framerate, num=len(wp)), wp)\r\n\r\n\r\n\r\n# mpl.figure(2)\r\n\r\n# for i in range(sigd.shape[0]):\r\n\r\n# sigd[i][sigd[i] < self.threshold*sigmax] = 0.\r\n\r\n# # find center of mass of areas above threshold\r\n\r\n# # mass = sigd[i].copy()\r\n\r\n# # mass[sigd[i] > 0.] = 1.\r\n\r\n# # structuring_element = [[0,1,0],[1,1,1],[0,1,0]]\r\n\r\n# # segmentation, segments = scipy.ndimage.label(mass, structuring_element)\r\n\r\n# # coords = scipy.ndimage.center_of_mass(sigd[i], segmentation, range(1,segments+1))\r\n\r\n# # xcoords = np.array([x[1] for x in coords])\r\n\r\n# # ycoords = np.array([x[0] for x in coords])\r\n\r\n# # cs[i] = (xcoords, ycoords)\r\n\r\n\r\n\r\n# # Calculating local maxima\r\n\r\n# lm = skif.peak_local_max(sigd[i], min_distance=2, threshold_rel=0.25, exclude_border=False, \r\n\r\n# indices=True, num_peaks=10, footprint=None, labels=None)\r\n\r\n# localmax[i] = [(m[0], m[1], sigd[i][(m[0], m[1])]) for m in lm]\r\n\r\n# # print ('i, local max: ',i, localmax)\r\n\r\n# mpl.subplot(5,5,i+1)\r\n# print ('shape of sigd: ',[np.shape(sigd),i])\r\n\r\n# imga1 = mpl.imshow(sigd[i], cmap=clist[i], vmin=0, origin='lower')\r\n\r\n# if len(localmax[i]) > 0:\r\n\r\n# max_fr = np.max([m[2] for m in localmax[i]])\r\n\r\n# else:\r\n\r\n# continue\r\n\r\n# scattersize = 30.\r\n\r\n# for k, lm in enumerate(localmax[i]):\r\n\r\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], edgecolors='k',\r\n\r\n# s=scattersize*lm[2]/max_fr, linewidths=0.125, alpha=0.5)\r\n\r\n# mpl.subplot(6,5,i+15+1)\r\n\r\n# wr = range(i*windowsize, i*windowsize+windowsize)\r\n\r\n# # print (' wr: len, min max: ', len(wr), min(wr), max(wr))\r\n\r\n# wmax = 0.\r\n\r\n# for lmax in localmax[i]: # was xcoords\r\n\r\n# wave = wdat[wr, lmax[0],lmax[1]]\r\n\r\n# wdff = (wave-wave[0])/wave[0]\r\n\r\n# if np.max(wdff) > wmax:\r\n\r\n# wmax = np.max(wdff)\r\n\r\n# mpl.plot(np.linspace(0., len(wave)*1./self.framerate, num=len(wave)),\r\n\r\n# wdff, color=clist2[i])\r\n\r\n# mpl.ylim(-0.1*wmax, wmax)\r\n\r\n# fig = mpl.figure(3)\r\n\r\n# for i in range(sigd.shape[0]):\r\n\r\n# if len(localmax[i]) == 0:\r\n\r\n# continue\r\n\r\n# max_fr = np.max([m[2] for m in localmax[i]])\r\n\r\n# for lm in localmax[i]:\r\n\r\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], \r\n\r\n# s=scattersize*lm[2]/max_fr, alpha=0.5, edgecolors='k')\r\n\r\n# mpl.ylim(0, sigd.shape[2])\r\n\r\n# mpl.xlim(0, sigd.shape[1])\r\n\r\n# mpl.axis('equal')\r\n\r\n mpl.show()\r\n\r\n print (' DF/F analysis finished.\\n')","def averageTime(self):\n \n pass","def investigate4DRepeatability():\n parentdir = '/home/rallured/Dropbox/Interferometer/SolarBFlat/Repeatability/'\n avgs = [1,2,4,8,16,32]\n\n #Temporal with fringes tilted\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTiltTemporal*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\n #Make progressive averaging plot\n plt.figure('TemporalTiltedFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Temporal,Tilted')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n reptemptilt = d[-1]-d[-2]\n figtemptilt = d[-1]\n\n #Dynamic with fringes tilted\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTilt_*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = [met.readFlatScript(fi.split('.')[0])[0] for fi in fn]\n #Make progressive averaging plot\n plt.figure('DynamicTiltedFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Dynamic,Tilted')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n repdyntilt = d[-1]-d[-2]\n figdyntilt = d[-1]\n \n #Temporal with fringes nulled\n fn = glob.glob(parentdir+'Nulled/17*.bin')\n fn.sort()\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\n #Make progressive averaging plot\n plt.figure('TemporalNulledFigure')\n for i in np.arange(6)*2:\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Temporal,Nulled')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n reptempnull = d[-1]-d[-2]\n figtempnull = d[-1]\n \n #Dynamic with fringes nulled\n d = pyfits.getdata('/home/rallured/Dropbox/Interferometer/'\n 'SolarBFlat/Repeatability/'\n 'Nulled/170103_Processed.fits')\n rep = np.array([d[i,0]-d[i,1] for i in range(32)])\n #Make progressive averaging plot\n plt.figure('DynamicNulledFigure')\n for i in [0,1,3,7,15,31]:\n f,p = fourier.meanPSD(d[i,0],win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label=str(i+1))\n plt.legend(loc='lower left')\n plt.title('Solar B PSD - Dynamic,Nulled')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n #Get repeatability\n repdynnull = d[-1][0]-d[-1][1]\n figdynnull = d[-1][0]\n\n #Make comparative repeatability plots with 32 averages\n plt.figure('CompareRepeatability')\n f,p = fourier.meanPSD(repdynnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\n f,p = fourier.meanPSD(repdyntilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\n f,p = fourier.meanPSD(reptemptilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\n f,p = fourier.meanPSD(reptempnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\n plt.legend(loc='lower left')\n plt.title('Solar B Repeatability - 32 Averages')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n\n #Make comparative figure plots with 32 averages\n plt.figure('CompareFigure')\n f,p = fourier.meanPSD(figdynnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\n f,p = fourier.meanPSD(figdyntilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\n f,p = fourier.meanPSD(figtemptilt,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\n f,p = fourier.meanPSD(figtempnull,win=np.hanning,dx=dx,irregular=True,\\\n minpx=200)\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\n plt.legend(loc='lower left')\n plt.title('Solar B Figure - 32 Averages')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n\n #Make parroting repeatability plots\n fig = plt.figure('Parroting')\n fig.add_subplot(2,2,1)\n plt.imshow(repdyntilt)\n plt.title('Dynamic Repeatability')\n plt.colorbar()\n fig.add_subplot(2,2,2)\n plt.imshow(reptemptilt)\n plt.title('Temporal Repeatability')\n plt.colorbar()\n fig.add_subplot(2,2,3)\n res = legendre2d(repdyntilt,xo=3,yo=3)[0]\n plt.imshow(repdyntilt-res)\n plt.title('Dynamic Repeatability Filtered')\n plt.colorbar()\n fig.add_subplot(2,2,4)\n res = legendre2d(reptemptilt,xo=3,yo=3)[0]\n plt.imshow(reptemptilt-res)\n plt.title('Temporal Repeatability Filtered')\n plt.colorbar()","def _doCalibration(self):\n self._cmdCalibration(2)","def calc_calories(gpx_track, wt = 175, activity='Run'):","def flatNoiseCGH():\n #Get data\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/NoiseStudy/FlatMeasurements/'\n d1,dx1 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas1.fits')\n d2,dx2 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas2.fits')\n p1,px1 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas1.fits')\n p2,px2 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas2.fits')\n p3,px3 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas1.fits')\n p4,px4 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas2.fits')\n\n #Construct baseline power spectra\n f1,pow1 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1)\n f2,pow2 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1,axis=1)\n \n #Construct parroted power spectra\n f3,pow3 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx1)\n f4,pow4 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx2,axis=1)\n f5,pow5 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx1)\n f6,pow6 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx2,axis=1)\n\n #Plot\n plt.loglog(f1,pow1/f1[0],label='Axial Baseline')\n plt.loglog(f2,pow2/f2[0],label='Azimuthal Baseline')\n plt.loglog(f3,pow3/f3[0],label='Pitch Axial')\n plt.loglog(f4,pow4/f4[0],label='Pitch Azimuthal')\n plt.loglog(f5,pow5/f5[0],label='Roll Axial')\n plt.loglog(f6,pow6/f6[0],label='Roll Azimuthal')\n plt.title('Residual Fringe Repeatability Impact')\n plt.xlabel('Frequency (1/mm)')\n plt.ylabel('Power ($\\mu$m$^2$ mm)')\n plt.grid()\n plt.legend(loc='lower left')\n\n return f1,pow1","def calibrate(cap, location):\n\n #Poisition and size of sensor\n [x, y, h, w] = location\n\n #show square to user and wait for key\n print(\"please, step away to clear the blue square displayed on screen and press q to continue\")\n while True:\n ret, frame = cap.read()\n cv2.namedWindow('Calibrate',cv2.WINDOW_NORMAL)\n show = cv2.rectangle(frame, (x,y), (x+w,y+h), (255, 0, 0) , 5)\n cv2.imshow('Calibrate', show)\n key = cv2.waitKey(1)\n if key == ord('q'):\n break\n\n #get first image, process and define window previous for iteration\n ret, frame = cap.read()\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n frame = cv2.GaussianBlur(frame, (7,7), 0)\n previous = frame[y:y+w,x:x+h]\n\n #set parameters for mean value of sensor, kernel of erode function,\n sampleNbMean = 50\n xi = np.empty((0, sampleNbMean))\n kernel = np.ones((5,5), np.uint8)\n\n #iterate over each frame until sample number\n for iteration in range(sampleNbMean):\n\n # Capture frame, draw the window and display to the user\n ret, frame = cap.read()\n # Image operation\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n frame = cv2.GaussianBlur(frame, (7,7), 0)\n\n #get present window\n present = frame[y:y+w,x:x+h]\n\n #add sample for mean, add diference of window with prieviuos\n xi = np.append(xi,\n np.sum(\n cv2.erode(\n cv2.bitwise_xor(present,previous), kernel, iterations=1)))\n\n #present image becomes previous before steping into next image\n previous = present\n\n #mean\n mean = np.sum(xi)/len(xi)\n\n #sigma\n sum = 0\n for sample in xi:\n sum += np.power(sample - mean, 2)\n sigma = np.sqrt(sum/len(xi))\n\n #close window\n cv2.destroyWindow('Calibrate')\n\n return mean, sigma","def fiducial_evolution():\n \n # fiducial model\n wangle = 180*u.deg\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\n x = pk['x'].to(u.kpc)\n xorig = x[:2]\n \n plt.close()\n fig, ax = plt.subplots(1,1,figsize=(6,6))\n \n plt.sca(ax)\n \n Nsnap = 8\n times = np.linspace(0,0.5,Nsnap)[::-1]\n angles = np.linspace(0,322,Nsnap)[::-1]*u.deg\n\n for e, t in enumerate(times):\n c = mpl.cm.Blues(0.05+0.85*(Nsnap-e)/Nsnap)\n #a = 0.5 + 0.5*(Nsnap-e)/Nsnap\n \n pk = pickle.load(open('../data/gd1_fiducial_t{:.4f}.pkl'.format(t), 'rb'))\n x = pk['x'].to(u.kpc)\n x_, y_ = x[0], x[1]\n \n plt.plot(x_[120:-120], y_[120:-120], '.', color=c, ms=10, zorder=Nsnap-e, rasterized=False)\n \n xt = 24*np.cos(angles[e]+90*u.deg)\n yt = 24*np.sin(angles[e]+90*u.deg)\n if e<Nsnap-1:\n txt = plt.text(xt, yt, '+ {:.2f} Gyr'.format(t), va='center', ha='center', fontsize='small', color='0.2', rotation=(angles[e]).value, zorder=10)\n txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none'))\n \n plt.text(0, 24, 'Flyby', va='center', ha='center', fontsize='small', color='0.2')\n\n lim = 27\n plt.xlim(-lim,lim)\n plt.ylim(-lim,lim)\n plt.gca().set_aspect('equal')\n \n plt.xlabel('x [kpc]')\n plt.ylabel('y [kpc]')\n \n plt.tight_layout()\n plt.savefig('../plots/loop_evolution.pdf')","def plot_calibration(df, x_input = \"Mean Predicted Avg\",\n y_input = \"Empirical Probability\",\n x_name=\"Mean Predicted\",\n y_name=\"Empirical Probability\",\n method_order = METHOD_ORDER, \n avg_x = False):\n\n methods = df['method_name']\n uniq_methods = pd.unique(methods)\n method_order = [j for j in METHOD_ORDER if j in uniq_methods]\n method_df = []\n\n if avg_x: \n df_copy = df.copy()\n new_list = [0]\n new_x_map = {}\n for method in uniq_methods: \n temp_vals = df[df['method_name'] == method][x_input]\n new_ar = np.vstack(temp_vals)\n new_ar = np.nanmean(new_ar, 0) # avg columnwise\n new_x_map[method] = new_ar\n df_copy[x_input] = [new_x_map[method] for method in methods]\n df = df_copy\n\n x, y = df[x_input].values, df[y_input].values\n\n\n method_df = [{x_name : xx, y_name : yy, \"Method\" : method}\n for x_i, y_i, method in zip(x, y, methods)\n for xx,yy in zip(x_i,y_i)]\n method_df = pd.DataFrame(method_df)\n sns.lineplot(x=x_name, y=y_name, hue=\"Method\", alpha=0.8,\n hue_order=method_order,\n data=method_df,\n palette = METHOD_COLORS)\n x = np.linspace(0,1,100)\n plt.plot(x, x, linestyle='--', color=\"black\")","def calculate(self):\n self.results['max'] = numpy.max(self.data)\n self.results['min'] = numpy.min(self.data)\n if self.type == 0:\n self.group_discrete_data()\n if self.type == 1:\n self.group_continuous_data()\n\n self.results['arithAvg'] = self.average([self.data[i] * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences)\n self.results['quadAvg'] = math.sqrt(\n self.average([(self.data[i] * self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences))\n if self.results['min'] > 0:\n self.results['geoAvg'] = math.exp(\n self.average([numpy.log(self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\n self.totalOccurrences))\n self.results['harmAvg'] = 1 / self.average(\n [(self.occurrences[i] / self.data[i]) for i in range(len(self.data))],\n self.totalOccurrences)\n else:\n self.results['geoAvg'] = self.results['harmAvg'] = \"N/A\"\n self.results['momentsR'] = self.moments(self.data, self.occurrences, 4)\n self.results['centralMomentsR'] = self.moments([(i - self.results['arithAvg']) for i in self.data],\n self.occurrences, 4)\n self.results['std'] = self.average(\n [self.occurrences[i] * abs(self.data[i] - self.results['arithAvg']) for i in range(len(self.data))],\n self.totalOccurrences)","def compare_averages_shell_pspec_dft():\n\n select_radius = 5. #degrees\n\n Nside=256\n Npix = 12 * Nside**2\n Omega = 4*np.pi/float(Npix)\n\n Nfreq = 100\n freqs = np.linspace(167.0, 177.0, Nfreq)\n dnu = np.diff(freqs)[0]\n Z = 1420/freqs - 1.\n\n sig = 2.0\n mu = 0.0\n shell = np.random.normal(mu, sig, (Npix, Nfreq))\n\n dV = comoving_voxel_volume(Z[Nfreq/2], dnu, Omega)\n variances = []\n means = []\n pks = []\n\n gs = gridspec.GridSpec(2, 3)\n fig = pl.figure()\n\n ax0 = pl.subplot(gs[0, 0:2])\n ax1 = pl.subplot(gs[1, 0])\n ax3 = pl.subplot(gs[1, 1])\n ax2 = pl.subplot(gs[:, 2])\n\n steps = range(10,110,10)\n vmin,vmax = min(steps),max(steps)\n normalize = mcolors.Normalize(vmin=vmin, vmax=vmax)\n colormap = cm.viridis\n\n for n in steps:\n Nkbins = 100\n kbins, pk = pspec_funcs.shell_project_pspec(shell, Nside, select_radius, freqs=freqs, Nkbins=Nkbins, N_sections=n, cosmo=True, method='dft', error=False)\n variances.append(np.var(pk[0:Nkbins-5]))\n means.append(np.mean(pk[0:Nkbins-5]))\n pks.append(pk)\n ax0.plot(kbins, pk, label=str(n), color=colormap(normalize(n)))\n\n ax0.axhline(y=dV*sig**2, color='k', lw=2.0)\n# ax0.legend()\n scalarmappable = cm.ScalarMappable(norm=normalize, cmap=colormap)\n scalarmappable.set_array(steps)\n fig.colorbar(scalarmappable,label=r'Number of snapshots', ax=ax0)\n ax0.set_ylabel(r\"P(k) [mK$^2$ Mpc$^{3}]$\")\n ax0.set_xlabel(r\"k [Mpc$^{-1}]$\")\n ax1.plot(steps, np.array(variances), label=\"Variance\")\n ax1.set_ylabel(r\"Variance(P(k)) [mK$^4$ Mpc$^{6}]$\")\n ax1.set_xlabel(u\"Number of 5° snapshots\")\n ax3.plot(steps, means, label=\"Mean\")\n ax3.set_ylabel(r\"Mean(P(k)) [mK$^2$ Mpc$^{3}]$\")\n ax3.set_xlabel(u\"Number of 5° snapshots\")\n ax1.legend()\n ax3.legend()\n im = ax2.imshow(np.array(pks)[:,0:Nkbins-5], aspect='auto')#, norm=mcolors.LogNorm())\n fig.colorbar(im, ax=ax2)\n print('Fractional deviation: ', np.mean(np.abs(pk - dV*sig**2)))\n pl.show()","def updatefig(*args):\n p1.set_array(turn(grid))\n p2.set_data(tally['time'], tally['sickos'])\n p3.set_data(tally['time'], tally['immune'])\n p4.set_data(tally['time'], tally['dead'])\n ax2.set_xlim(0, max(tally['time']))\n # ax2.set_ylim(0, max(max(sickos), max(immune)))\n # End sim if the disease is gone\n if tally['sickos'][-1] == 0:\n ani.event_source.stop()\n end_time = time.process_time()\n show_summary()\n print(\"Process time:\", end_time - start_time)\n return p1, p2, p3, p4,","def read_calibrated(self):\n\n self.read_sensors()\n\n print(\"uncalibrated readings\")\n self.print_sensor_values(self.sensorValues)\n\n for i in range(0, self.NUM_SENSORS):\n denominator = self.calibratedMax[i] - self.calibratedMin[i]\n val = 0\n if denominator != 0:\n val = (self.sensorValues[i] - self.calibratedMin[i]) * 1000 / denominator\n if val < 0:\n val = 0\n elif val > 1000:\n val = 1000\n self.sensorValues[i] = val\n\n print(\"calibrated readings\")\n self.print_sensor_values(self.sensorValues)","def _calibrate_measurement(self):\n\n cold_blackbody = bb_radiance(self.cbb.header.cbb_temperature + 273.15,\n self.cbb.data.wavelength)\n warm_blackbody = bb_radiance(self.wbb.header.wbb_temperature + 273.15,\n self.wbb.data.wavelength)\n\n self.wbb.data.average_spectrum[0] = 1\n self.wbb.data.average_spectrum[2047] = 1\n\n calibration_slope = ((warm_blackbody - cold_blackbody) /\n (self.wbb.data.average_spectrum - self.cbb.data.average_spectrum))\n calibration_offset = warm_blackbody - (self.wbb.data.average_spectrum * \n calibration_slope)\n\n self.wbb.calibrate_file(calibration_slope, calibration_offset)\n self.cbb.calibrate_file(calibration_slope, calibration_offset)\n self.sam.calibrate_file(calibration_slope, calibration_offset)\n\n if not self.dwr is None:\n self.dwr.calibrate_file(calibration_slope, calibration_offset)\n\n plate_temperature = self.dwr.header.spare_f[0]\n if (self.plate == -1) :\n plate_emissivity = self.dwr.header.spare_f[1]\n\n plate_blackbody = bb_radiance(plate_temperature + 273.15,\n self.dwr.data.wavelength)\n plate_emission = plate_emissivity * plate_blackbody\n\n self.dwr.data.average_spectrum = ((self.dwr.data.average_spectrum - \n plate_emission) / (1 - plate_emissivity))","def folding(eventfile,Porb,nbins):\n times = fits.open(eventfile)[1].data['TIME'] #getting array of times\n gtis_data = fits.open(eventfile)[2].data #getting GTIs\n T = sum([ gtis_data[i]['STOP']-gtis_data[i]['START'] for i in range(len(gtis_data)) ]) #exposure time\n\n gtis_conform = []\n for i in range(len(gtis_data)):\n gtis_conform.append([gtis_data[i][0],gtis_data[i][1]]) #conform to the input that Stingray uses\n\n phase_sr,prof_sr,err_sr = fold_events(times,1/Porb,gtis=np.array(gtis_conform),ref_time=times[0],nbin=nbins)\n phase_sr_expo,prof_sr_expo,err_sr_expo = fold_events(times,1/Porb,gtis=np.array(gtis_conform),ref_time=times[0],expocorr=True,nbin=nbins)\n\n total_phase_sr = list(phase_sr) + list(phase_sr+1)\n total_prof_sr = list(prof_sr)*2\n total_err_sr = list(err_sr)*2\n\n total_phase_sr_expo = list(phase_sr_expo) + list(phase_sr_expo+1)\n total_prof_sr_expo = list(prof_sr_expo)*2\n total_err_sr_expo = list(err_sr_expo)*2\n\n plt.figure()\n plt.errorbar(x=total_phase_sr,y=total_prof_sr/T,yerr=total_err_sr/T,color='r',drawstyle='steps-mid')\n plt.errorbar(x=total_phase_sr_expo,y=total_prof_sr_expo/T,yerr=total_err_sr_expo/T,color='b',drawstyle='steps-mid')\n plt.legend(('Folded profile','Exposure-corrected'),loc='best',fontsize=12)\n plt.title(str(pathlib.Path(eventfile).name) +', exposure-corrected (using Stingray fold_events)',fontsize=12)\n plt.xlabel('Phase',fontsize=12)\n plt.ylabel('Counts/s',fontsize=12)\n\n return total_phase_sr_expo,total_prof_sr_expo/T,total_err_sr_expo/T","def run(self):\n bridge = CvBridge()\n rate = rospy.Rate(10)\n while not rospy.is_shutdown():\n dist, offset = self.find_position(self.focal_length, self.real_height)\n\n print(\"EST DISTANCE: \" + str(dist) + ' inches')\n print(\"EST OFFSET: \" + str(offset) + ' inches')\n print(\"--------------\")\n\n #heading averaging\n self.last_point = self.current_point\n self.current_point = offset[0]\n new_slope = (self.current_point - self.last_point)\n if new_slope != 0:\n new_slope = new_slope / abs(new_slope)\n if self.current_slope == 1:\n if new_slope < 0:\n self.average = self.current_sum / self.count\n self.current_sum = 0\n self.count = 0\n self.current_sum += self.current_point\n self.count += 1\n self.current_slope = new_slope\n\n #publish the heading and the average heading\n self.heading_pub.publish(offset[0])\n self.avg_pub.publish(self.average)\n\n #put a red circle on the image where the average heading is\n if dist != 0:\n center_x = int(self.average*self.focal_length/dist + self.image_center[0])\n center_y = int(-1.0*offset[1]*self.focal_length/dist + self.image_center[1])\n cv_marked_image = cv2.circle(self.image, (center_x, center_y), 15, (0,0,255), 15)\n marked_image = bridge.cv2_to_imgmsg(cv_marked_image, encoding='bgr8')\n self.image_pub.publish(marked_image)\n rate.sleep()","def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\t#labels = ['no APMB', 'APMB']\n\t#if labels == '':\n\tlabels = steps\n\tdeep = {}\n\t#uzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\t\tprint(pointsFile)\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\t'''\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t#normalize\n\tuz_fem = uz_fem / uzmax\n\tur_fem = ur_fem / uzmax\n\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\t'''\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def plot_mean_hfo(evlist,color='blue', xlim =[-1,1], figure_size=(10,10),dpi=600,saveplot = None):\n f = plt.figure(figsize=figure_size,dpi=dpi)\n \n \n \n \n raw = np.array([]) # creating a empty array \n filt = np.array([]) # creating a empty array\n pxx = np.array([]) # creating a empty array\n nwave, a = evlist[0].waveform.shape\n time_v = np.linspace(-1,1,nwave,endpoint=True)\n npw, = evlist[0].spectrum.nPxx.shape\n F = evlist[0].spectrum.F\n for hfo in evlist:\n raw = np.append(raw, hfo.waveform[:,0])\n #ax1.plot(time_v,hfo.waveform[:,0],lw=.5)\n filt = np.append(filt, hfo.waveform[:,1])\n #ax2.plot(time_v,hfo.waveform[:,1],lw=.5)\n pxx = np.append(pxx, hfo.spectrum.nPxx)\n \n raw = raw.reshape(len(evlist),nwave)\n filt = filt.reshape(len(evlist),nwave)\n pxx = pxx.reshape(len(evlist),npw)\n\n \n \n \n ax1 = plt.subplot(311)\n m = np.mean(raw,0)\n s = np.std(raw,0)/np.sqrt(raw.shape[0])\n plt.plot(time_v,m,'k',lw=2)\n #ax1.fill_between(time_v,m+s,m-s, facecolor=color, alpha=0.1)\n ax1.set_xlim(xlim)\n adjust_spines(ax1, ['left'])\n \n ax2 = plt.subplot(312)\n m = np.mean(filt,0)\n s = np.std(filt,0)/np.sqrt(filt.shape[0])\n plt.plot(time_v,m,'k',lw=2)\n #ax2.fill_between(time_v,m+s,m-s, facecolor=color, alpha=0.1)\n ax2.set_xlim(xlim)\n adjust_spines(ax2, ['left', 'bottom'])\n \n ax3 = plt.subplot(313)\n m = np.mean(pxx,0)\n s = np.std(pxx,0)/np.sqrt(pxx.shape[0])\n plt.plot(F,m,'k',lw=2)\n ax3.fill_between(F,m+s,m-s, facecolor=color, alpha=0.1)\n adjust_spines(ax3, ['left', 'bottom'])\n \n if saveplot != None:\n if type(saveplot) == str: \n plt.savefig(saveplot, bbox_inches='tight')\n else:\n raise Exception('saveplot should be a string')","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def avg(self):\n return sum(self.times) / len(self.times)","def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:","def display(self,anchor_name = ANCHOR_NAME ,mode = '2D'):\n res = self.read_mes()\n \n \n \n \n ref_points = res[0]\n positions = res[1]\n \n \n \n # print(ref_points)\n # print(rangings)\n out = [] # will be returned\n measured_positions = [] # measured ranging value for the reference point\n real_positions = [] # real ranging value for the reference point\n \n #abs_standard_deviation = []\n #relative_standard_deviation = []\n \n abs_accuracies = []\n #relative_accuracies = []\n \n #angles = angle(ref_points,anchor_name)\n \n for (i,rp) in enumerate(ref_points):\n serie = positions[i]\n \n (real_position,mean_position,mean_accuracy) = self.extract_serie(serie,rp)\n \n # getting error for anchor A\n #print(get_ranging_error('A',mean_position,rp) )\n measured_positions.append(mean_position)\n real_positions.append(real_position)\n abs_accuracies.append(mean_accuracy)\n \n global_accuracy = np.mean(abs_accuracies)\n print(\"average accuracy :\" + str(global_accuracy) )\n \n \n \n \n # displaying averaged values\n \n \n \n \n \n \n measured_x = []\n measured_y = []\n measured_z = []\n real_x = []\n real_y = []\n real_z = []\n for pos in measured_positions:\n (x,y,z) = pos\n measured_x.append(x)\n measured_y.append(y)\n measured_z.append(z)\n \n for pos in real_positions:\n (x,y,z) = pos\n real_x.append(x)\n real_y.append(y)\n real_z.append(z)\n \n \n \n \n \n \n \n if (mode == '2D'):\n \n \n \n # plotting results\n \n # creating figures \n fig1 = plt.figure(\"Accuracy\")\n fig2 = plt.figure(\"Positions\") \n \n # creating axes \n ax1 = fig1.add_subplot(111,projection='3d')\n ax1.view_init(elev = 45, azim = 240)\n ax1.set_title(\"absolute accuracy\")\n ax1.plot(real_x[:],real_y[:],abs_accuracies[:])\n \n \n \n \n \n ax2 = fig2.add_subplot(111)\n ax2.set_title(\"Real positions\")\n ax2.scatter(real_x[:],real_y[:])\n \n ax2 = fig2.add_subplot(111)\n ax2.set_title(\"Measured positions\")\n ax2.scatter(measured_x[:],measured_y[:])\n \n \n \n \n \n \n \n if (mode == '3D'):\n # plotting results\n \n # creating figures \n fig1 = plt.figure(\"Accuracy\")\n fig2 = plt.figure(\"Positions\") \n \n # creating axes \n ax1 = fig1.add_subplot(111,projection='3d')\n ax1.view_init(elev = 45, azim = 240)\n ax1.set_title(\"absolute accuracy\")\n ax1.plot(real_x[:],real_y[:],abs_accuracies[:])\n \n \n \n \n \n ax2 = fig2.add_subplot(111,projection='3d')\n ax2.view_init(elev = 45, azim = 240)\n ax2.set_title(\"Real positions\")\n ax2.scatter(real_x[:],real_y[:],real_z[:])\n \n ax2 = fig2.add_subplot(111,projection='3d')\n ax2.view_init(elev = 45, azim = 240)\n ax2.set_title(\"Measured positions\")\n ax2.scatter(measured_x[:],measured_y[:],measured_z[:])\n \n \n \n if (DISPLAY): \n plt.show()\n \n \n return(out)","def update_average_best_fit(self):\r\n # print(result_buffer)\r\n total = len(self.result_buffer)\r\n left_fit, right_fit = np.empty((0, 3)), np.empty((0, 3))\r\n left_curve_rad, right_curve_rad = [], []\r\n vehicle_offset = []\r\n for i in range(total):\r\n calc_fit_dict = self.result_buffer[i]\r\n left_fit = np.append(left_fit, [calc_fit_dict['left_fit']], axis=0)\r\n right_fit = np.append(right_fit, [calc_fit_dict['right_fit']], axis=0)\r\n left_curve_rad.append(calc_fit_dict['left_curve_rad'])\r\n right_curve_rad.append(calc_fit_dict['right_curve_rad'])\r\n vehicle_offset.append(calc_fit_dict['vehicle_offset'])\r\n self.avg_fit_dict['left_fit'] = np.mean(left_fit, axis=0)\r\n self.avg_fit_dict['right_fit'] = np.mean(right_fit, axis=0)\r\n self.avg_fit_dict['left_curve_rad'] = np.mean(left_curve_rad)\r\n self.avg_fit_dict['right_curve_rad'] = np.mean(right_curve_rad)\r\n self.avg_fit_dict['vehicle_offset'] = np.mean(vehicle_offset)\r\n # print(avg_fit_dict)\r\n return","def plot_averaged_amplitude(self):\r\n\r\n tremap = np.arange(0, self.period, 1./self.framerate)\r\n\r\n ipy_offset = -2\r\n\r\n # find center of image\r\n\r\n self.ipx = int(self.imageData.shape[1]/2.)\r\n\r\n self.ipy = int(self.imageData.shape[2]/2.)\r\n\r\n posx = range(1, self.imageData.shape[1]-1, 2)\r\n\r\n colormap = mpl.cm.gist_ncar\r\n\r\n colx = [colormap(i) for i in np.linspace(0, 0.9, (len(posx)))]\r\n\r\n for i, px in enumerate(posx):\r\n\r\n remapped1 = self.measure_amplitude(self.ipy+ipy_offset, px)\r\n\r\n mpl.plot(tremap, remapped1/self.meanimagevalue, 'o-', markerfacecolor=colx[i], markersize=2.0)\r\n\r\n mpl.title('Averaged Amplitude Center')\r\n\r\n return (ipy_offset, posx, colx)","def run_calib(projector=OPTOMA_HD33()):\n w, h = (0.2160, 0.2794)\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\n [-w/2, 0, 0], [w/2, 0, 0],\n [-w/2, 0, h/2], [w/2, 0, h/2]])\n\n global img_points, going\n img_points = []\n\n try:\n window = Window()\n window.MoveXY(1600,0)\n window.ShowFullScreen(True)\n going = True\n\n @window.eventx\n def EVT_MOUSE_EVENTS(evt):\n global going, img_points\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\n img_points.append(evt.Position)\n print('Picked point %d of 6' % (len(img_points)))\n if len(img_points) == len(obj_points):\n print \"Done\"\n going = False\n\n print(\"\"\"[Extrinsic Calibration] \n\nThere should be 6 points marked on the table and backdrop. \nMoving the mouse over the projected display, click each of the points\nin order:\n (left top, on the backdrop),\n (right top, on the backdrop),\n (left center, on the crease),\n (right center, on the crease),\n (left bottom, on the table),\n (right bottom, on the table)\n\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\n\nClick the six points:\n\"\"\")\n\n while going: cv.WaitKey(10)\n\n finally:\n window.Close()\n\n img_points = np.array(img_points, 'f')\n projector.calibrate_extrinsic(img_points, obj_points)\n\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\n print('OK')","def test4():\n\t\n\tprint('This takes a while to compute - be patient!')\n\t\n\td = np.linspace(-15000,15000,300)\n\t#Voigt\n\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\n\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\n\tpol = np.array([1.0,0.0,0.0])\n\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\n\t\n\tfig2 = plt.figure()\n\tax1a = fig2.add_subplot(411)\n\tax2a = fig2.add_subplot(412,sharex=ax1a)\n\tax3a = fig2.add_subplot(413,sharex=ax1a)\n\tax4a = fig2.add_subplot(414,sharex=ax1a)\n\t\n\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\n\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\n\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\n\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\n\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\n\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\n\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\n#\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\n\t\n\t\n\tax4a.set_xlabel('Detuning (MHz)')\n\tax1a.set_ylabel('I -45')\n\tax2a.set_ylabel('I +45')\n\tax3a.set_ylabel('Ix')\n\tax4a.set_ylabel('Iy')\n\t\n\tax4a.set_xlim(d[0],d[-1]+3000)\n\tax4a.legend(loc=0)\n\t\n\tplt.show()","def recall_precision_shots(movie_id):\n \n scenes = moviegraphs.load_scenes(movie_id, all_mg)\n # s is the starting second of the movie (after the opneing credits)\n # e is the ending second of the movie (before the ending credits)\n s, e = scenes[0][0], scenes[-1][1]\n with open(json_dir + movie_id + '.json') as f:\n data = json.load(f)\n \n MG = [i for i in moviegraphs.load_cuts(vid_dir, movie_id) if s < i < e]\n VI = [i for i in videoindexer.load_cuts(data) if s < i < e]\n \n count = 0\n for i in range(len(MG)):\n if i == 0: prev = 0\n for j in range(prev, len(VI)):\n if VI[j] - 1 <= MG[i] <= VI[j] + 1:\n prev = j + 1\n count += 1\n return (round(count / len(VI), 3), round(count / len(MG), 3))","def plot_sum(self):\n fig, ax = plt.subplots()\n ax.set_title(\"Unpolarized intensity: I_up + I_down\")\n ax.set_xlabel(\"Time (microseconds)\")\n ax.set_ylabel('Intensity')\n\n if (self.is_attribute(\"time\") & self.is_attribute(\"intensity_up\") & \n self.is_attribute(\"intensity_up_sigma\") &\n self.is_attribute(\"intensity_down\") & \n self.is_attribute(\"intensity_down_sigma\") &\n self.is_attribute(\"intensity_up_total\") &\n self.is_attribute(\"intensity_down_total\")):\n np_excl = numpy.array(self.excluded, dtype=bool)\n np_notexcl = numpy.logical_not(np_excl)\n np_time = numpy.array(self.time, dtype=float)\n np_up = numpy.array(self.intensity_up, dtype=float)\n np_sup = numpy.array(self.intensity_up_sigma, dtype=float)\n np_up_mod = numpy.array(self.intensity_up_total, dtype=float)\n np_down = numpy.array(self.intensity_down, dtype=float)\n np_sdown = numpy.array(self.intensity_down_sigma, dtype=float)\n np_down_mod = numpy.array(self.intensity_down_total, dtype=float)\n np_sum = np_up + np_down\n np_sum_mod = np_up_mod + np_down_mod\n np_ssum = numpy.sqrt(numpy.square(np_sup)+numpy.square(np_sdown))\n ax.plot(np_time, np_sum_mod, \"k-\", label=\"model\")\n ax.errorbar(np_time[np_notexcl], np_sum[np_notexcl], yerr=np_ssum[np_notexcl], fmt=\"ko\", alpha=0.2, label=\"experiment\")\n ax.errorbar(np_time[np_excl], np_sum[np_excl], yerr=np_ssum[np_excl], fmt=\"rs\", alpha=0.2, label=\"excluded\")\n\n y_min_d, y_max_d = ax.get_ylim()\n param = y_min_d-(np_sum - np_sum_mod).max()\n coeff = np_notexcl.astype(int)\n\n ax.plot([np_time.min(), np_time.max()], [param, param], \"k:\")\n ax.plot(np_time, coeff*(np_sum - np_sum_mod)+param, \"r-\", alpha=0.7,\n label=\"difference\")\n elif (self.is_attribute(\"time\") & self.is_attribute(\"intensity\") & \n self.is_attribute(\"intensity_total\") &\n self.is_attribute(\"intensity_sigma\")):\n np_excl = numpy.array(self.excluded, dtype=bool)\n np_notexcl = numpy.logical_not(np_excl)\n np_time = numpy.array(self.time, dtype=float)\n np_sum = numpy.array(self.intensity, dtype=float)\n np_sum_mod = numpy.array(self.intensity_total, dtype=float)\n np_ssum = numpy.array(self.intensity_sigma, dtype=float)\n ax.plot(np_time, np_sum_mod, \"k-\", label=\"model\")\n ax.errorbar(np_time[np_notexcl], np_sum[np_notexcl], yerr=np_ssum[np_notexcl], fmt=\"ko\", alpha=0.2, label=\"experiment\")\n ax.errorbar(np_time[np_excl], np_sum[np_excl], yerr=np_ssum[np_excl], fmt=\"rs\", alpha=0.2, label=\"excluded\")\n\n y_min_d, y_max_d = ax.get_ylim()\n param = y_min_d-(np_sum - np_sum_mod).max()\n coeff = np_notexcl.astype(int)\n\n ax.plot([np_time.min(), np_time.max()], [param, param], \"k:\")\n ax.plot(np_time, coeff*(np_sum - np_sum_mod)+param, \"r-\", alpha=0.7,\n label=\"difference\")\n ax.legend(loc='upper right')\n fig.tight_layout()\n return (fig, ax)","def plot_overscan_variation(t_lst, overscan_lst, figfile):\n \n # Quality check plot of the mean overscan value over time \n fig = plt.figure(figsize=(8,6), dpi=150)\n ax2 = fig.add_axes([0.1,0.60,0.85,0.35])\n ax1 = fig.add_axes([0.1,0.15,0.85,0.35])\n #conversion of the DATE-string to a number\n date_lst = [dateutil.parser.parse(t) for t in t_lst]\n datenums = mdates.date2num(date_lst)\n\n ax1.plot_date(datenums, overscan_lst, 'r-', label='mean')\n ax2.plot(overscan_lst, 'r-', label='mean')\n for ax in fig.get_axes():\n leg = ax.legend(loc='upper right')\n leg.get_frame().set_alpha(0.1)\n ax1.set_xlabel('Time')\n ax2.set_xlabel('Frame')\n ax1.set_ylabel('Overscan mean ADU')\n ax2.set_ylabel('Overscan mean ADU')\n # adjust x and y limit\n y11,y12 = ax1.get_ylim()\n y21,y22 = ax2.get_ylim()\n z1 = min(y11,y21)\n z2 = max(y21,y22)\n ax1.set_ylim(z1,z2)\n ax2.set_ylim(z1,z2)\n ax2.set_xlim(0, len(overscan_lst)-1)\n # adjust rotation angle of ticks in time axis\n plt.setp(ax1.get_xticklabels(),rotation=30)\n\n # save figure\n fig.savefig(figfile)\n plt.close(fig)","def coldaverage( names):\n\n rs = radioastronomy.Spectrum() # create input and average structures\n avenames = names # create an output list to average\n\n# assume only a limited range of galactic latitudes are available\n# not range above +/-60.\n use60Range = False\n minGlat = 90. # initialize to extremea\n maxGlat = -90.\n maxEl = -90.\n minEl = 90.\n ncold = 0\n\n # for all input files\n for filename in names:\n\n parts = filename.split('/')\n nparts = len(parts)\n if nparts == 1:\n aname = parts[0]\n else:\n aname = parts[nparts-1]\n\n parts = aname.split('.')\n nparts = len(parts)\n if nparts < 2:\n print 'File is not an astronomy file: ',filename\n continue\n else:\n extension = parts[nparts-1]\n\n extension = extension.upper()\n if extension != 'AST': # speed up by only looking at astronomy files\n continue\n \n rs.read_spec_ast(filename) # An observation, read values\n\n if rs.telel < 0: # only working with observations, skip elevation <= 0.\n continue\n\n maxGlat = max( rs.gallat, maxGlat)\n minGlat = min( rs.gallat, minGlat)\n maxEl = max( rs.telel, maxEl)\n minEl = min( rs.telel, minEl)\n # end for all files loop, looking for max el and latitude ranges\n\n # if any high galactic latitudes, use only above +/-60d \n if minGlat < -60. or maxGlat > 60.:\n minGlat = -60.\n maxGlat = 60.\n else: # else no high galactic latitude data\n # use highest galactic latitudes - +/-5.degrees\n if -minGlat > maxGlat: # if negative latitudes higher\n minGlat = minGlat + 5.\n maxGlat = 90.\n else: # else positive latitudes higher\n maxGlat = maxGlat - 5.\n minGlat = -90.\n\n # only use the elevations above 60 degrees, if any\n if maxEl > 60.:\n maxEl = 60.\n else:\n maxEl = maxEl - 10. #else must use highest elevations available\n\n # now average coldest data for calibration\n for filename in names:\n\n rs.read_spec_ast(filename)\n rs.azel2radec() # compute ra,dec from az,el\n\n if rs.telel < maxEl:\n continue\n\n if rs.gallat > maxGlat or rs.gallat < minGlat:\n avenames[ncold] = filename\n ncold = ncold + 1\n # end of for all files loop\n\n ncold, cold = average( avenames[0:ncold]) # now use generic program for averages\n if ncold < 1:\n print 'No Cold load files; can not calibrate!'\n exit()\n\n return ncold, cold, minEl, maxEl","def calibrate(self, eventlog, calibrate=True, validate=False):\n\n\n # # # #calculate thresholds (degrees to pixels)\n self.pxfixtresh = self._deg2pix(self.screendist, self.fixtresh, self.pixpercm)\n # in pixels per millisecons\n self.pxspdtresh = self._deg2pix(self.screendist, self.spdtresh / 1000.0, self.pixpercm)\n # in pixels per millisecond**2\n self.pxacctresh = self._deg2pix(self.screendist, self.accthresh / 1000.0, self.pixpercm)\n\n # calibration image file\n calibImg = c.CALIBIMG\n\n # initialize a sound\n snd = sound.Sound(value=c.CALIBSOUNDFILE)\n snd.setVolume(0.5)\n\n # image scaling range\n bit = 0.02\n scaleRange = ([x / 100.0 for x in range(60, 30, -2)] + [x / 100.0 for x in range(30, 60, 2)])\n\n if calibrate:\n\n if not self.eyetracker:\n print(\"WARNING! libtobii.TobiiProTracker.calibrate: no eye trackers found for the calibration!\")\n self.stop_recording()\n return False\n\n calibration = tr.ScreenBasedCalibration(self.eyetracker)\n\n calibrating = True\n calibration.enter_calibration_mode()\n\n while calibrating:\n\n eventlog.write([\"Calibration started at \", clock.get_time()])\n print \"----------> Starting calibration...\"\n\n # original (normalised) points_to_calibrate = [(0.5, 0.5), (0.9, 0.1), (0.1, 0.1), (0.9, 0.9), (0.1, 0.9)]\n # pixel values are calculated based on the normalised points. With (1920,1200):\n # self.points_to_calibrate calculated values: [(960, 600), (192, 1080), (192, 120), (1728, 1080), (1728, 120)]\n\n # calibration for all calibration points\n for i in range(0,len(self.points_to_calibrate)):\n\n point = self.points_to_calibrate[i]\n\n eventlog.write([\"\\nCalibrating point {0} at: \".format(point), clock.get_time()])\n print \"----------> Calibrating at point \", point\n\n # play the soundfile\n snd.play()\n\n # Shrink from big size to small\n scale = 1\n for frameN in range(20): # 20 frames -> 1/3 sec shrinking (180 to 108)\n\n self.c_screen.clear()\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\n drawCoreImage(self.c_screen, point, i)\n self.disp.fill(self.c_screen)\n self.disp.show()\n scale = scale - bit\n\n # shrink and grow while 'space' is pressed\n s = 0\n for frameN in range(12000): # 108 -> 54, 15 frames (1/4 s) and backwards\n\n s = frameN%30\n scale = scaleRange[s]\n self.c_screen.clear()\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\n drawCoreImage(self.c_screen, point, i)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n if self.kb.get_key(keylist=['space'],timeout=10, flush=False)[0] == 'space':\n break\n\n # collect results for point\n normalized_point = self._px_2_norm(point)\n collect_result = calibration.collect_data(normalized_point[0], normalized_point[1])\n print(\"----------> Collecting results for point \", point)\n eventlog.write([\"Collecting result for point {0} at: \".format(point), clock.get_time()])\n\n if collect_result != tr.CALIBRATION_STATUS_SUCCESS:\n eventlog.write([\"Recollecting result for point {0} at: \".format(point), clock.get_time()])\n # Try again if it didn't go well the first time.\n # Not all eye tracker models will fail at this point, but instead fail on ComputeAndApply.\n calibration.collect_data(normalized_point[0], normalized_point[1])\n\n # Shrink back to big size\n scaleUp = [x / 100.0 for x in range(int(scale*100), 100, 2)]\n for scale in scaleUp:\n self.c_screen.clear()\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\n drawCoreImage(self.c_screen, point, i)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n\n # image rolling to next point\n # pixelised self.points_to_calibrate = [(960, 600), (192, 1080), (192, 120), (1728, 1080), (1728, 120)]\n if (i < len(self.points_to_calibrate)-1):\n\n \"\"\"\n screen ratio: 16/10\n The steps for moving the images should be 16, 10 or 8, 5\n \"\"\"\n # center -> bottom left / (960, 600) -> (192, 1080) - 48 frames\n while point[0] >= self.points_to_calibrate[i+1][0]:\n self.c_screen.clear()\n point = (point[0]-16, point[1]+10)\n self.c_screen.draw_image(calibImg, pos=point)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n # bottom-left -> top-left / (192, 1080) -> (192, 120)\n # AND\n # bottom-right -> top-right / (1728, 1080) -> (1728, 120) - 80 frames\n while point[1] > self.points_to_calibrate[i+1][1]:\n self.c_screen.clear()\n point = (point[0], point[1]-12)\n self.c_screen.draw_image(calibImg, pos=point)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n # top-left -> bottom-right / (192, 120) -> (1728, 1080) - 96 frames\n while point[0] < self.points_to_calibrate[i+1][0] and not point[1] == self.points_to_calibrate[i+1][1]:\n self.c_screen.clear()\n point = (point[0]+16, point[1]+10)\n self.c_screen.draw_image(calibImg, pos=point)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n\n print(\"------------> Calculating calibration result....\")\n\n calibration_result = calibration.compute_and_apply()\n\n eventlog.write([\"\\nCompute and apply returned {0} and collected at {1} points.\\n\".\n format(calibration_result.status, len(calibration_result.calibration_points))])\n print(\"------------> Compute and apply returned {0} and collected at {1} points.\".\n format(calibration_result.status, len(calibration_result.calibration_points)))\n\n\n\n # Show image after calibration\n self.c_screen.clear()\n self.c_screen.draw_image(c.ATT_IMG)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n if calibration_result.status != tr.CALIBRATION_STATUS_SUCCESS:\n eventlog.write([\"\\n\\nWARNING! libtobii.TobiiProTracker.calibrate: Calibration was unsuccessful!\\n\\n\"])\n print \"Calibration was unsuccessful.\\nPress 'R' to recalibrate all points\\nor 'SPACE' to continue without calibration\"\n key = self.kb.get_key(keylist=['space', 'r'], timeout=None)[0]\n if key == 'r':\n recalibration_points = [0]\n elif key == 'space':\n recalibration_points = []\n\n else:\n # call showCalibrationResults function to present the results on screen 0. The function returns a list\n logfiledir = os.path.dirname(os.path.abspath(self.datafilepath))\n recalibration_points = showCalibrationResults(logfiledir, calibration_result)\n\n # if the list is empty, calibration is finished\n if len(recalibration_points) == 0:\n eventlog.write([\"\\nCalibration finished at \", clock.get_time()])\n calibrating = False\n\n # if the list contains only '0', the calibration was unsuccessful, recalibrate all points\n elif (recalibration_points[0] == 0):\n eventlog.write([\"\\nRecalibrating all points...\"])\n calibrating = True\n # if the list contains only '1', recalibrate all points despite successful calibration\n elif (recalibration_points[0] == 1):\n eventlog.write([\"\\nRecalibrating all points...\"])\n for point in self.points_to_calibrate:\n calibration.discard_data(point[0], point[1])\n calibrating = True\n # recalibrate the returned points\n else:\n eventlog.write([\"\\nRecalibrating {0} points...\".format(len(recalibration_points))])\n self.points_to_calibrate = [self._norm_2_px(p) for p in recalibration_points]\n for point in self.points_to_calibrate:\n calibration.discard_data(point[0], point[1])\n calibrating = True\n\n\n calibration.leave_calibration_mode()\n eventlog.write([\" Leaving calibration mode...\", clock.get_time()])\n self.stop_recording()\n self._write_enabled = True\n self.disp.close()","def find_change_points_fill(self):\r\n # Fill data with moving window of mean heading and circular stdev\r\n # - get filled data at 5 second interval\r\n # - calculate headings of filled data\r\n # - calculate mean and circular stdev in moving window. \r\n # - look for points where forward window mean differs from backward\r\n # window mean by more than 2 stdev\r\n rec_fill = self.rec_smooth_fill\r\n segs = self.make_segments(set_depth=True, input_rec_track=rec_fill,\r\n overwrite_rec_seg=False)\r\n # need rec_track to get valid data points for t-statistic calculation\r\n rec_raw = self.rec_track\r\n not_flagged = np.where(rec_raw.flagged==0)[0]\r\n rec_raw_valid = rec_raw[not_flagged]\r\n nfill = len(rec_fill)\r\n nseg = nfill - 1\r\n window = 12\r\n cvar, cavg = self.circular_std_dev(window=int(window/2), headings=segs.head)\r\n change_pt = np.zeros(nfill, np.bool_)\r\n change_pt0 = np.zeros(nfill, np.bool_)\r\n p_stat = np.ones(nfill, np.float64)\r\n small_cstd = 0.1*np.pi\r\n for nf in range(int(window/2+1),int(nfill-window/2-1)):\r\n nf_before = int(nf - window/4)\r\n nf_after = int(nf + window/4)\r\n cb = cavg[nf_before]\r\n ca = cavg[nf_after]\r\n #dy = np.sin(cb - ca)\r\n #dx = np.cos(cb - ca)\r\n #del_avg = math.atan2(dy, dx)\r\n del_avg = (cb-ca+np.pi)%(2.0*np.pi)-np.pi\r\n #avg_var = np.average([cvar[nf_before], cvar[nf_after]])\r\n #cstd = max(np.sqrt(avg_var),small_cstd)\r\n t1 = segs.t1[nf_before]\r\n t2 = segs.t2[nf_after]\r\n tf = rec_fill.Sec[nf]\r\n td = rec_raw_valid.Sec\r\n # calculate sample size\r\n n1 = max(1, np.sum(np.logical_and(td >= t1, td <= tf)))\r\n n2 = max(1, np.sum(np.logical_and(td <= t2, td >= tf)))\r\n #idet = np.where((td >= t1) & (td <= t2))[0]\r\n #nd = len(idet) # number of original detections in window\r\n # http://www.stat.yale.edu/Courses/1997-98/101/meancomp.htm\r\n # degrees of freedom is min(n1,n2)-1\r\n #df = 2*nd - 2\r\n #df = max(1, df)\r\n #t_stat = del_avg/(cstd*np.sqrt(df))\r\n #avg_var = np.average([cvar[nf_before], cvar[nf_after]])\r\n denominator = np.sqrt(cvar[nf_before]/n1 + cvar[nf_after]/n2)\r\n denominator = max(0.05*np.pi, denominator)\r\n t_stat = abs(del_avg)/denominator\r\n df = max(1, min(n1, n2)-1)\r\n p_stat[nf] = 1 - stats.t.cdf(t_stat, df=df)\r\n #print self.ID, nd, df, del_avg, cstd, t_stat, p_stat[nf]\r\n #change_pt[nf] = abs(del_avg) > 3.*avg_std\r\n change_pt0[nf] = p_stat[nf] < 0.05\r\n for nf in range(int(window/2+1),int(nfill-window/2-1)):\r\n # flag current point only if it is the smallest p_stat in window\r\n if change_pt0[nf]:\r\n nf_before = nf - int(window/4)\r\n nf_after = nf + int(window/4)\r\n nf_min = np.argmin(p_stat[nf_before:nf_after])\r\n if nf == nf_min + nf_before:\r\n change_pt[nf] = True\r\n\r\n self.df_smooth_fill = self.df_smooth_fill.assign(change_pt=change_pt)\r\n self.df_smooth_fill = self.df_smooth_fill.assign(p_stat=p_stat)\r\n self.rec_smooth_fill = self.df_smooth_fill.to_records()\r\n\r\n return","def measure(mode, x, y, x0, x1, thresh = 0):\n xt = x.view(numpy.ndarray) # strip Metaarray stuff -much faster!\n v = y.view(numpy.ndarray)\n \n xm = ma.masked_outside(xt, x0, x1).T\n ym = ma.array(v, mask = ma.getmask(xm))\n if mode == 'mean':\n r1 = ma.mean(ym)\n r2 = ma.std(ym)\n if mode == 'max' or mode == 'maximum':\n r1 = ma.max(ym)\n r2 = xm[ma.argmax(ym)]\n if mode == 'min' or mode == 'minimum':\n r1 = ma.min(ym)\n r2 = xm[ma.argmin(ym)]\n if mode == 'median':\n r1 = ma.median(ym)\n r2 = 0\n if mode == 'p2p': # peak to peak\n r1 = ma.ptp(ym)\n r2 = 0\n if mode == 'std': # standard deviation\n r1 = ma.std(ym)\n r2 = 0\n if mode == 'var': # variance\n r1 = ma.var(ym)\n r2 = 0\n if mode == 'cumsum': # cumulative sum\n r1 = ma.cumsum(ym) # Note: returns an array\n r2 = 0\n if mode == 'anom': # anomalies = difference from averge\n r1 = ma.anom(ym) # returns an array\n r2 = 0\n if mode == 'sum':\n r1 = ma.sum(ym)\n r2 = 0\n if mode == 'area' or mode == 'charge':\n r1 = ma.sum(ym)/(ma.max(xm)-ma.min(xm))\n r2 = 0\n if mode == 'latency': # return first point that is > threshold\n sm = ma.nonzero(ym > thresh)\n r1 = -1 # use this to indicate no event detected\n r2 = 0\n if ma.count(sm) > 0:\n r1 = sm[0][0]\n r2 = len(sm[0])\n if mode == 'count':\n r1 = ma.count(ym)\n r2 = 0\n if mode == 'maxslope':\n return(0,0)\n slope = numpy.array([])\n win = ma.flatnotmasked_contiguous(ym)\n st = int(len(win)/20) # look over small ranges\n for k in win: # move through the slope measurementwindow\n tb = range(k-st, k+st) # get tb array\n newa = numpy.array(self.dat[i][j, thisaxis, tb])\n ppars = numpy.polyfit(x[tb], ym[tb], 1) # do a linear fit - smooths the slope measures\n slope = numpy.append(slope, ppars[0]) # keep track of max slope\n r1 = numpy.amax(slope)\n r2 = numpy.argmax(slope)\n return(r1, r2)","def eeg_det_ptp_avg(array,win_p1,win_n1,win_p2,tim):\t\n\tnsub,npts = array.shape\n\tidx_p1 = np.squeeze(np.logical_and(tim>=win_p1[0],tim<=win_p1[1]))\n\tidx_n1 = np.squeeze(np.logical_and(tim>=win_n1[0],tim<=win_n1[1]))\n\tidx_p2 = np.squeeze(np.logical_and(tim>=win_p2[0],tim<=win_p2[1]))\n\t\n\tptp_val = np.zeros(nsub)\n\tfor i in range(nsub):\t\n\t\tp1 = np.mean(array[i,idx_p1],axis=0)\n\t\tn1 = np.mean(array[i,idx_n1],axis=0)\t\n\t\tp2 = np.mean(array[i,idx_p2],axis=0)\n\t\tptp_val[i] = (p1+p2)/2 - n1\n\t\t\n\treturn ptp_val","def track_quality_metrics(self, masked=False):\r\n grd = self.grd\r\n if masked:\r\n not_flagged = np.where(self.rec_track.flagged==0)[0]\r\n tr = self.rec_track[not_flagged]\r\n # smooth track\r\n #trs = self.rec_smooth_pos[not_flagged]\r\n # assume that smoothed position is already masked\r\n trs = self.rec_smooth_pos\r\n seg = self.make_segments(set_depth=True, input_rec_track=tr)\r\n mask = not_flagged\r\n else:\r\n tr = self.rec_track\r\n trs = self.rec_smooth_pos\r\n seg = self.rec_seg\r\n mask = None\r\n detects = len(tr.X)\r\n possible_detects = (tr.Sec[-1] - tr.Sec[0])/dt_signal\r\n non_detects = possible_detects - detects\r\n frac_detects = float(detects)/float(possible_detects)\r\n max_depth = np.max(tr.depth)\r\n z_over_H = np.minimum(1.,np.divide(tr.Z,np.maximum(depth_min,tr.depth)))\r\n ivalid = np.where(np.isfinite(z_over_H))[0]\r\n avg_ht = np.average(1.0 - z_over_H[ivalid])\r\n avg_z = np.average(tr.Z)\r\n valid_depth = np.where(np.isfinite(tr.depth))[0]\r\n avg_depth = np.average(tr.depth[valid_depth])\r\n velocity_sd = np.std(seg.speed)\r\n dv = self.del_velocity(input_rec_track=trs)\r\n del_velocity_mag = np.average(np.abs(dv))\r\n del_velocity_sd = np.std(np.abs(dv))\r\n max_speed = np.max(np.absolute(seg.speed))\r\n detects_outside_grid = self.detects_outside_grid()\r\n t_elapsed = tr.Sec[-1] - tr.Sec[0]\r\n ivalid = np.where(np.isfinite(trs.noise))[0]\r\n pos_error = np.average(trs.noise[ivalid])\r\n t_entry = tr.dnums[0]\r\n hour = (t_entry - math.trunc(t_entry))*24.\r\n if (hour > 7) and (hour < 19):\r\n daytime_entry = True\r\n else:\r\n daytime_entry = False\r\n mnames = ['ID', 'ndetects','non_detects', 'frac_detects', 'max_depth', \r\n 'avg_depth', 'avg_ht', 'avg_z', 'vel_sd', \r\n 'dvel_mag', 'dvel_sd', 'invalid_cell', 'pos_error', \r\n 't_elapsed','daytime_entry']\r\n metrics = [self.ID, detects, non_detects, frac_detects, max_depth, \r\n avg_depth, avg_ht, avg_z, velocity_sd, del_velocity_mag, \r\n del_velocity_sd, detects_outside_grid, pos_error, \r\n t_elapsed, daytime_entry]\r\n self.mnames = mnames\r\n self.metrics = metrics\r\n\r\n return mnames, metrics\r\n #print self.ID, non_detects, frac_detects, min_depth, velocity_sd, \\\r\n # detects_outside_grid\r","def EPI():\n TE = np.array([4.22, 33.81, 63.39, 92.98, 122.6, 152.2, 181.7, 211.3, 240.9, 270.5])\n upper_left = np.array([697.3, 367.0, 217.5, 115.8, 51.8, 23.2, 14.8, 8.7, 6.1, 4.6])\n center = np.array([1110.2, 907.8, 813.6, 745.2, 692.8, 637.0, 564.9, 521.0, 450.2, 401.6])\n lower_right = np.array([723.0, 419.2, 224.1, 126.4, 61.8, 32.4, 15.1, 8.8, 3.9, 3.8])\n upper_center = np.array([782.2, 499.4, 279.5, 154.5, 88.6, 58.2, 43.8, 38.2, 38.2, 36.0])\n\n area = [upper_left, center, upper_center, lower_right]\n colors = [\"#1f77b4\", \"#ff7f0e\", \"#2ca02c\", \"#d62728\"]\n name = [\"Upper left area\", \"Center area\", \"Up center area\", \"Lower right area\"]\n x_new = np.linspace(4.22, 270.5, 10000)\n for i, j, k in zip(area, colors, name):\n popt, _ = curve_fit(M_xy, TE, i, p0=np.array([200, 300]))\n M0, T2 = popt[0], popt[1]\n y_new = M_xy(x_new, M0, T2)\n plt.scatter(TE, i)\n plt.plot(x_new, y_new, \"--\", c=j, label=\"Fit: %s\" % k + f\", $T_2$={T2:.2f}\")\n plt.legend(loc=\"best\")\n plt.grid()\n plt.ylabel(\"Mean Signal Intensity\")\n plt.xlabel(\"TE [ms]\")\n plt.show()","def performancePlot(plot=\"ROC\"):\n fig, ax = plt.subplots()\n colors = {\"ML\": \"red\", \"Null YFP\": \"gold\", \"Null DAPI\": \"blue\"}\n mapp = pickle.load(open(\"pickles/mapp_fold_-1.pk\", \"rb\"))\n null_mapp = pickle.load(open(\"pickles/null_YFP_mapp_fold_-1.pk\", \"rb\"))\n null_DAPI_mapp = pickle.load(open(\"pickles/null_DAPI_mapp_fold_-1.pk\", \"rb\"))\n \n i = 0\n for m in [mapp, null_mapp, null_DAPI_mapp]:\n coordinates = [] #list of tuples (thresh, x point, y point) to plot\n for key in m: ##for each threshold\n TPs = sum([x[0] for x in m[key]])\n FPs = sum([x[1] for x in m[key]])\n TNs = sum([x[2] for x in m[key]])\n FNs = sum([x[3] for x in m[key]])\n if plot == \"PRC\":\n x = TPs / float(TPs + FNs) #recall (TPR)\n y = TPs / float(TPs + FPs) #precision\n if plot == \"ROC\":\n x = FPs / float(FPs + TNs) #FPR \n y = TPs / float(TPs + FNs) #recall (TPR)\n if not (np.isnan(x) or np.isnan(y)): \n coordinates.append((key, x, y))\n coordinates = sorted(coordinates, key=lambda x: x[0]) ##sort by threshold\n x = [t[1] for t in coordinates][::-1]\n y = [t[2] for t in coordinates][::-1]\n # print(i, coordinates)\n # thresholds = [entry[0] for entry in coordinates]\n # for j, txt in enumerate(thresholds):\n # ax.annotate(txt, (x[j], y[j]), fontsize=5)\n auc = np.trapz(y,x)\n if i == 0:\n label = \"ML\"\n if i == 1:\n label = \"Null YFP\"\n if i == 2:\n label = \"Null DAPI\" \n ax.plot(x, y, linewidth=2.0, color=colors[label], label=\"{} Model, AUC = {}\".format(label, str(round(auc, 2)))) \n i += 1\n plt.title(\"{} Curves\".format(plot), fontname=\"Times New Roman\", fontsize=12)\n ax.set_xlim((0,1))\n ax.set_ylim((0,1))\n plt.rc('font',family='Times New Roman')\n plt.xticks(fontname=\"Times New Roman\", fontsize=12)\n plt.yticks(fontname=\"Times New Roman\", fontsize=12)\n if plot == \"ROC\":\n ax.set_xlabel(\"False Positive Rate\", fontname=\"Times New Roman\", fontsize=12)\n ax.set_ylabel(\"True Positive Rate\",fontname=\"Times New Roman\", fontsize=12)\n ax.plot([0, .5, 1], [0,.5, 1], linestyle=\"--\", linewidth=1.0, color=\"black\")\n ax.legend(loc='lower right',prop={\"family\":\"Times New Roman\", \"size\":10})\n plt.savefig(\"matplotlib_figures/ROC.png\", dpi=300)\n if plot == \"PRC\":\n positives = TPs + FNs ##doesn't matter which map we use, positive prevalence independent of map \n total = TPs + FPs + TNs + FNs \n positive_prevalence = positives / float(total)\n ax.hlines(y=positive_prevalence, xmin=0, xmax=1, linestyle=\"--\", linewidth=1.0, color=\"black\")\n ax.set_xlabel(\"Recall\", fontname=\"Times New Roman\", fontsize=12)\n ax.set_ylabel(\"Precision\",fontname=\"Times New Roman\", fontsize=12)\n ax.set_xlim((0,1))\n ax.set_ylim((0,1))\n ax.legend(loc='upper right',prop={\"family\":\"Times New Roman\", \"size\":10})\n plt.savefig(\"matplotlib_figures/PRC.png\", dpi=300)","def calculate_average_angles(tube_steps,angular_file,pixel_step,tube_sep,extra_dummy=[]):\n no_of_overlaps = int(round((len(tube_steps)+len(extra_dummy))/pixel_step))-1\n correction_array = Array(read_horizontal_corrections(angular_file))\n no_of_tubes = len(correction_array)\n counter = array.zeros(no_of_tubes+no_of_overlaps,int)\n final_values = array.zeros(no_of_tubes+no_of_overlaps,float)\n for stepno in range(no_of_overlaps+1):\n counter[stepno:stepno+no_of_tubes]+=array.ones(no_of_tubes,int)\n final_values[stepno:stepno+no_of_tubes]+=correction_array\n ave_angles = final_values/counter\n print 'Check: average angles ' + `ave_angles`\n print 'Check: counter' + `counter`\n print 'Check: no of overlaps, tubes: %d %d ' % (no_of_overlaps,no_of_tubes)\n # Now apply these average corrections to the actual angles\n real_step = pixel_step\n if len(tube_steps)<pixel_step:\n real_step = len(tube_steps) #for when we have no overlap and missing steps\n final_values = array.zeros((no_of_tubes+no_of_overlaps)*real_step)\n print 'Final values has len %d' % len(final_values)\n for stepno in range(no_of_tubes+no_of_overlaps):\n final_values[stepno*real_step:(stepno+1)*real_step] = tube_steps + tube_sep*stepno + ave_angles[stepno]\n return final_values","def analysis(avg, yellow, var, edges, texture): \n r = [a[0] for a in avg]\n ravg = numpy.mean(r)\n rmin = min(r) \n rmax = max(r)\n g = [a[1] for a in avg]\n gavg = numpy.mean(g)\n gmin = min(g) \n gmax = max(g)\n b = [a[2] for a in avg]\n bavg = numpy.mean(b)\n bmin = min(b) \n bmax = max(b)\n \n \n print('Red Statistics') \n print('Average is ', ravg) \n print('Min is ', rmin)\n print('Max is ', rmax)\n \n print('Green Statistics') \n print('Average is ', gavg) \n print('Min is ', gmin)\n print('Max is ', gmax)\n \n print('Blue Statistics') \n print('Average is ', bavg) \n print('Min is ', bmin)\n print('Max is ', bmax)\n \n \n yavg = numpy.mean(yellow)\n ymin = min(yellow)\n ymax = max(yellow)\n \n print 'Yellow Statistics' \n print 'Average is ', yavg \n print 'Min is ', ymin \n print 'Max is ', ymax\n \n vavg = numpy.mean(var)\n vmin= min(var)\n vmax = max(var) \n \n print 'Color Variance Statistics' \n print 'Average is ', vavg \n print 'Min is ', vmin \n print 'Max is ', vmax\n \n eavg = numpy.mean(edges)\n emin= min(edges)\n emax = max(edges) \n \n print 'Edge Count Statistics' \n print 'Average is ', eavg \n print 'Min is ', emin \n print 'Max is ', emax\n \n tavg = numpy.mean(texture) \n tmin= min(texture)\n tmax = max(texture) \n print 'Texture Statistics' \n print 'Average is ', tavg \n print 'Min is ', tmin \n print 'Max is ', tmax","def atmgaincal(self,flim=[10000,10500]):\n sind=self.getscanind()\n ind=self.expandcal()\n amm=np.tile(self.am,(self.nf,1)).T\n x=(self.spec-self.b[ind])/self.g[ind];x=x[sind]\n x=x/amm[sind]\n y=x[ np.where((self.za[sind]>=25) & (self.za[sind]<=35))[0] ]\n \n #for k in range(y.shape[0]):\n # y[k]=y[k]-np.nanmedian(y[k])\n\n f=self.f+9500\n find=np.where((f>=flim[0]) & (f<=flim[1]))[0]\n \n for k in range(y.shape[0]):\n x=self.f[find];\n yy=y[k,find];\n p=np.polyfit(x,yy,deg=1);\n y[k]=y[k]-np.poly1d(p)(self.f)\n\n return y","def perform_event_analysis():\n\n tol = 2.0 # Arcmin\n calib_on_colours = False\n\n params = get_args()\n\n log = start_log(params)\n\n (star_catalog,image_trios,catalog_header) = read_combined_star_catalog(params,log)\n\n lightcurves = read_lightcurves(params,log)\n\n target = find_target_data(params,star_catalog,lightcurves,image_trios,log)\n\n (source, blend) = calc_source_blend_params(params,log)\n\n source = calc_source_lightcurve(source, target, log)\n\n measure_photometric_source_colours(params,target,log)\n\n (det_idx, cat_idx, close_cat_idx) = index_valid_star_entries(star_catalog,\n target,tol,log,\n valid_cat=True)\n\n deltas = calibrate_instrumental_colour_colour_diagram(params,star_catalog,\n catalog_header,target,\n det_idx,cat_idx,close_cat_idx,\n log,\n calib=calib_on_colours)\n\n RC = localize_red_clump(star_catalog,close_cat_idx,log)\n\n analyse_colour_mag_diagrams(params,star_catalog,catalog_header,\n target, source,blend,RC,\n det_idx,cat_idx,close_cat_idx,log)\n\n RC = measure_RC_offset(params,RC,target,log)\n\n (target,source,blend) = calc_phot_properties(target, source, blend, RC, log)\n\n plot_colour_colour_diagram(params,star_catalog,catalog_header,\n target, source, blend, RC,\n det_idx,cat_idx,close_cat_idx, log)\n\n (source, blend) = match_source_blend_isochrones(params,source,blend,log)\n\n (source, blend) = calc_source_blend_ang_radii(source, blend, log)\n\n (source, blend) = calc_source_blend_physical_radii(source, blend, log)\n\n (source,blend) = calc_source_blend_distance(source, blend, RC, log)\n\n lens = calc_lens_parameters(params, source, RC, log)\n\n output_red_clump_data_latex(params,RC,log)\n\n output_source_blend_data_latex(params,source,blend,log)\n\n output_lens_parameters_latex(params,source,lens,log)","def meanRegion(thk_s,thk_p,thk_diff):\n meanp = np.nanmean(np.nanmean(thk_p,axis=1),axis=1)\n means = np.nanmean(np.nanmean(thk_s,axis=1),axis=1)\n \n print '\\n --- [[%s to %s N, %s to %s E]] ---' % (latmin,latmax,lonmin,lonmax)\n print 'Average Thickness (Satellite) == %s meters' % np.nanmean(means)\n print 'Average Thickness (PIOMAS) == %s meters' % np.nanmean(meanp)\n print 'Average Difference == %s meters' % (np.nanmean(means)-np.nanmean(meanp))\n \n yearmin = 2004\n yearmax = 2015\n years = np.arange(yearmin,yearmax+1,1)\n years = np.setdiff1d(years,[2010]) ### no satellite data in 2010\n \n fig = plt.figure()\n ax = plt.subplot(111)\n \n ### Call parameters\n plt.rcParams['text.usetex']=True\n plt.rcParams['font.family'] = 'sans-serif'\n plt.rcParams['font.sans-serif'] = 'Avant Garde'\n \n plt.plot(meanp,color='darkred',linewidth=2,linestyle='-',\n label=r'PIOMAS')\n plt.plot(means,color='forestgreen',linewidth=2,linestyle='-',\n label=r'Satellite')\n plt.axvline(6,color='k',linewidth=3,linestyle='-')\n \n labelsy = map(str,np.arange(0,6,1))\n labelsx = map(str,years)\n plt.xticks(np.arange(len(years)),labelsx)\n plt.yticks(np.arange(0,6,1),labelsy)\n plt.ylabel(r'\\textbf{Thickness (meters)}',fontsize=13)\n \n ### Adjust axes in time series plots \n def adjust_spines(ax, spines):\n for loc, spine in ax.spines.items():\n if loc in spines:\n spine.set_position(('outward', 10))\n else:\n spine.set_color('none') \n if 'left' in spines:\n ax.yaxis.set_ticks_position('left')\n else:\n ax.yaxis.set_ticks([])\n \n if 'bottom' in spines:\n ax.xaxis.set_ticks_position('bottom')\n else:\n ax.xaxis.set_ticks([]) \n \n ### Adjust axes spines\n adjust_spines(ax, ['left', 'bottom'])\n ax.spines['top'].set_color('none')\n ax.spines['right'].set_color('none')\n plt.grid(color='b',zorder=1,alpha=0.3)\n \n plt.legend(shadow=False,fontsize=11,loc='upper right',\n fancybox=True)\n \n plt.text(2,-0.8,r'\\textbf{ICESat}',fontsize=13)\n plt.text(7.3,-0.8,r'\\textbf{PIOMAS}',fontsize=13)\n \n fig.suptitle(r'\\textbf{SIT Difference [Satellite - PIOMAS]}',fontsize=16)\n plt.savefig(directoryfigure + 'test5_difftseries.png',dpi=300)","def testStatisticsRamp(self):\n\n \n nx = 101\n ny = 64\n img = afwImage.ImageF(afwGeom.Extent2I(nx, ny))\n \n z0 = 10.0\n dzdx = 1.0\n mean = z0 + (nx/2)*dzdx\n stdev = 0.0\n for y in range(ny):\n for x in range(nx):\n z = z0 + dzdx*x\n img.set(x, y, z)\n stdev += (z - mean)*(z - mean)\n\n stdev = math.sqrt(stdev/(nx*ny - 1))\n \n stats = afwMath.makeStatistics(img, afwMath.NPOINT | afwMath.STDEV | afwMath.MEAN)\n testmean = stats.getValue(afwMath.MEAN)\n teststdev = stats.getValue(afwMath.STDEV)\n \n self.assertEqual(stats.getValue(afwMath.NPOINT), nx*ny)\n self.assertEqual(testmean, mean)\n self.assertEqual(teststdev, stdev )\n \n stats = afwMath.makeStatistics(img, afwMath.STDEV | afwMath.MEAN | afwMath.ERRORS)\n mean, meanErr = stats.getResult(afwMath.MEAN)\n sd = stats.getValue(afwMath.STDEV)\n \n self.assertEqual(mean, img.get(nx/2, ny/2))\n self.assertEqual(meanErr, sd/math.sqrt(img.getWidth()*img.getHeight()))\n \n # ===============================================================================\n # sjb code for percentiles and clipped stats\n \n stats = afwMath.makeStatistics(img, afwMath.MEDIAN)\n self.assertEqual(z0 + dzdx*(nx - 1)/2.0, stats.getValue(afwMath.MEDIAN))\n \n stats = afwMath.makeStatistics(img, afwMath.IQRANGE)\n self.assertEqual(dzdx*(nx - 1)/2.0, stats.getValue(afwMath.IQRANGE))\n \n stats = afwMath.makeStatistics(img, afwMath.MEANCLIP)\n self.assertEqual(z0 + dzdx*(nx - 1)/2.0, stats.getValue(afwMath.MEANCLIP))","def repeat(start, end, roi_times=None, timeres=2, coords=None, ar=None,\n split_temps=None, em_wlen=None, plotminmax=False, plotstd=False,\n hist_type='plain', loaddata=False):#, output=None):\n #if isinstance(output, str):\n # from matplotlib import use\n # use(output)\n import matplotlib.pyplot as plt\n import matplotlib.dates as mdates\n\n #loaddata = False\n\n print start, end\n start, end = parse(start), parse(end)\n \n s = []\n t = []\n p = []\n \n #if flares == []:\n # return s, t, p\n\n timerange = tr(start, end)\n delta = dt.timedelta(hours=timeres)\n ntimes = int(timerange.seconds()/delta.total_seconds())\n times = [time.start() for time in timerange.split(ntimes)]\n \n ntemps = 141\n tempsovertime = np.zeros((ntemps, ntimes))\n \n means = np.zeros(len(times))\n p95s = np.zeros(len(times))\n loopmeans = np.zeros(len(times))\n if plotminmax:\n maxes = np.zeros(len(times))\n mins = np.zeros(len(times))\n if plotstd:\n stds = np.zeros(len(times))\n loopstds = np.zeros(len(times))\n if em_wlen:\n meanem = np.zeros(len(times))\n if plotminmax:\n maxem = np.zeros(len(times))\n minem = np.zeros(len(times))\n if plotstd:\n stdem = np.zeros(len(times))\n\n for i, date in enumerate(times):\n data_only = True\n try:\n if ar == 'all':\n plotar = None\n else:\n plotar = ar\n results = output_maps(date, plotar, coords, 'data', split_temps,\n subimsize=50, calc_em=em_wlen, data_only=data_only)#True)#, linear=True)\n if isinstance(results, tuple):\n tempmap, emmap = results\n else:\n tempmap = results\n data = tempmap.data\n except DownloadError as de:\n data = np.zeros((512, 512))\n print de.msg\n except:\n print 'KHAAAAAAAN! Some part of the temperature-plotting process failed.'\n raise\n data = np.zeros((512, 512))\n if em_wlen:\n emmap = np.zeros((512, 512))\n \n t.append(np.nanmean(data))\n p.append(np.nanmax(data))\n \n data = data.flatten()\n data2 = data.copy()\n data2[data == 0.0] = np.NaN\n data2 = data2[np.isfinite(data)]\n data2.sort()\n temps, bins = np.histogram(data, bins=ntemps, density=False, range=(5.6, 7.0))\n temps = (temps/float(data.size))*100.0\n tempsovertime[:, i] = temps\n\n #loops = data[data >= split_temps]\n #data = data[data < split_temps]\n\n means[i] = np.nanmean(data2)\n try:\n p95s[i] = data2[round(0.95 * len(data2))-1]\n except IndexError:\n p95s[i] = np.NaN\n #loopmeans[i] = np.nanmean(loops)\n if plotminmax:\n maxes[i] = np.nanmax(data)\n mins[i] = np.nanmin(data)\n if em_wlen:\n maxem[i] = np.nanmax(emmap)\n minem[i] = np.nanmin(emmap)\n if plotstd:\n stds[i] = np.nanstd(data)\n if em_wlen:\n stdem[i] = np.nanstd(emmap)\n #loopstds[i] = np.nanstd(loops)\n \n tempsovertime[tempsovertime <= 0.1] = np.nan\n\n xmin, xmax = mdates.datestr2num([str(start), str(end)])\n fig = plt.figure(figsize=(36, 18))\n ax = fig.add_subplot(111, axisbg='k')\n plot_title = 'Temperature distribution of corona\\n{:%Y/%m/%d %H:%M} - {:%Y/%m/%d %H:%M}'.format(start, end)\n if roi_times:\n plot_title += '\\nRegion observed: {:%Y/%m/%d %H:%M} - {:%Y/%m/%d %H:%M}'.format(*roi_times)\n plt.title(plot_title)\n if hist_type == 'plain':\n plt.imshow(tempsovertime[30:106, :], extent=[xmin, xmax, 5.9, 6.65],\n aspect='auto', interpolation='none', origin='lower',\n cmap='coolwarm', vmin=np.nanmin(tempsovertime[65:106, :]),\n vmax=np.nanmax(tempsovertime[65:106, :]))\n elif hist_type == 'loops':\n plt.imshow(tempsovertime[65:106, :], extent=[xmin, xmax, 6.25, 6.65],\n aspect='auto', interpolation='none', origin='lower',\n cmap='coolwarm', vmin=np.nanmin(tempsovertime[65:106, :]),\n vmax=np.nanmax(tempsovertime[65:106, :]))\n elif hist_type == 'full':\n plt.imshow(tempsovertime, extent=[xmin, xmax, 5.6, 7.0],\n aspect='auto', interpolation='none', origin='lower',\n cmap='coolwarm', vmin=np.nanmin(tempsovertime),\n vmax=np.nanmax(tempsovertime))\n plt.tight_layout()\n ax.xaxis_date()\n fig.autofmt_xdate()\n plt.colorbar(orientation='horizontal')\n plt.savefig('/media/huw/temp-time_hists/distribution_over_time_{}'.format(ar))\n plt.close()\n\n\n means[np.where(means == 0.0)] = np.nan\n if plotstd:\n stds[np.where(stds == 0.0)] = np.nan\n loopstds[loopstds == 0.0] = np.nan\n\n try:\n tnums = mdates.date2num([ti for ti in times])\n print maxes\n print len(maxes)\n fig = plt.figure(figsize=(18, 14))\n ax = fig.add_subplot(111)\n plt.title('Variation of temperature over time; AR{}'.format(ar), \n fontsize=32)\n plt.plot(tnums, maxes, label='Maximum temperature', color='red')\n plt.axhline(np.nanmean(maxes))\n print tnums\n print len(tnums)\n ax.xaxis_date()\n fig.autofmt_xdate()\n plt.legend(loc=4, fontsize=16)\n plt.xlabel('Date', fontsize=24)\n plt.ylabel('log(T)', fontsize=24)\n #plt.savefig('/media/huw/temp_plots/temp_plot_{}_b'.format(ar))\n plt.savefig('/home/drew/Dropbox/ARs/temps_{}_b'.format(ar))\n plt.close()\n\n \"\"\"diff = ((maxes-p95s)/p95s)*100.0\n fig = plt.figure(figsize=(18, 14))\n ax = fig.add_subplot(1, 1, 1)\n plt.title('Percentage difference between max and 95th %-ile; AR{}'.format(ar), \n fontsize=32)\n plt.plot(tnums, diff, color='black')\n plt.scatter(fldates, [np.nanmax(diff)]*len(fldates))\n for flare in flares:\n ax.text(sunpy.time.parse_time(flare['event_peaktime']), np.nanmax(diff)+0.01, flare['fl_goescls'][0])\n ax.xaxis_date()\n fig.autofmt_xdate()\n plt.xlabel('Date', fontsize=24)\n plt.ylabel('log(T)', fontsize=24)\n #plt.savefig('/media/huw/temp_plots/temp_plot_{}'.format(ar))\n plt.savefig('Dropbox/ARs/diffs_{}'.format(ar))\n plt.close()\"\"\"\n \n except:# ValueError:\n print \"Can't plot the temperature graph because matplotlib is being a whiney douche\"\n print tnums\n raise\n\n return s, t, p, times","def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',\n\t\t\t\tsteps=['step01','step02'],\n\t\t\t\t#labels='',\n\t\t\t\tshow=True,\n\t\t\t\txscale=1e3,\n\t\t\t\tyscale=1e-2):\n\tplt.figure()\n\t#path = '/Users/scott/Desktop/elastic'\n\n\t# Deep source\n\tlabels = ['no APMB', 'APMB']\n\tdeep = {}\n\tuzmax = 0.824873455364\n\t# NOT sure why hardcoded...\n\tuzmax = 1\n\tfor i,outdir in enumerate(steps):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 30.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\n\t\tdeep[outdir] = uz_fem/uz_fem\n\n\n\t# Shallow Source\n\tshallow = {}\n\tuzmax = 0.949652827795 # Why?\n\tfor i,outdir in enumerate(['step11','step12']):\n\t\tpointsFile = os.path.join(path, outdir, 'points.h5')\n\n\t\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n\n\t\tX = x / xscale\n\t\tY1 = ux / yscale\n\n\t\tx_fem = X #/ xscale #double scaling!\n\t\tur_fem = Y1 #/ yscale\n\t\tuz_fem = uz / yscale\n\n\t\t#print(pointsFile)\n\t\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\n\n\t\t#normalize\n\t\tuz_fem = uz_fem / uzmax\n\t\tur_fem = ur_fem / uzmax\n\t\tx_fem = x_fem / 20.0\n\n\t\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\n\t\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n\t\tshallow[outdir] = uz_fem/ur_fem\n\n\t# Annotate\n\tplt.axhline(color='k',lw=0.5)\n\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n\tplt.legend()\n\tplt.grid()\n\t#plt.ylim(-0.5, 3.5)\n\t#plt.savefig('deep.png',bbox_inches='tight')\n\t#plt.savefig('shallow.png',bbox_inches='tight')\n\n\t# normalized\n\tplt.ylim(-0.5, 4)\n\tplt.xlim(0,10)\n\tplt.xlabel('Normalized Radial Distance [R / D]')\n\tplt.ylabel('Normalized Displacement [U / Uz_max]')\n\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\n\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\n\n\n\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\n\t'''\n\tplt.figure()\n\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\n\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\n\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\n\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\n\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\n\t#plt.xlabel('Normalized Distance [R/d]')\n\tplt.ylabel('Ratio [Uz/Ur]')\n\tplt.title('Ratio of vertical to radial displacement')\n\tplt.legend()\n\tplt.show()\n\t'''","def radiation_measurement_analysis():\n import pint\n ureg = pint.UnitRegistry()\n\n mrem_h = ureg.parse_units('mrem') / ureg.hour\n m = ureg.parse_units('meters')\n s = ureg.parse_units('seconds')\n\n # Measurements of background radiation\n bg_dist = ureg.parse_expression('10 m') # estimate of how far away we are wrt background\n background_rows = [\n dict(vid=1, distance=bg_dist, rad=0.023 * mrem_h, capture_time=0.0 * s),\n dict(vid=1, distance=bg_dist, rad=0.022 * mrem_h, capture_time=0.0 * s),\n dict(vid=1, distance=bg_dist, rad=0.023 * mrem_h, capture_time=4.0 * s),\n dict(vid=1, distance=bg_dist, rad=0.021 * mrem_h, capture_time=5.0 * s),\n dict(vid=1, distance=bg_dist, rad=0.023 * mrem_h, capture_time=11.0 * s),\n dict(vid=1, distance=bg_dist, rad=0.023 * mrem_h, capture_time=16.0 * s),\n dict(vid=1, distance=bg_dist, rad=0.024 * mrem_h, capture_time=20.0 * s),\n ]\n\n # Measurements of sample radiation\n esp_dist = ureg.parse_expression('1 inch').to(m) / 2 # estimate of how far we are from the sample when very close\n dist0_rows = [\n dict(vid=2, distance=esp_dist, rad=0.060 * mrem_h, capture_time=0.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.061 * mrem_h, capture_time=3.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.060 * mrem_h, capture_time=5.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.059 * mrem_h, capture_time=9.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.060 * mrem_h, capture_time=10.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.059 * mrem_h, capture_time=11.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.057 * mrem_h, capture_time=12.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.058 * mrem_h, capture_time=13.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.059 * mrem_h, capture_time=14.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.060 * mrem_h, capture_time=15.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.061 * mrem_h, capture_time=16.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.062 * mrem_h, capture_time=18.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.062 * mrem_h, capture_time=18.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.064 * mrem_h, capture_time=20.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.065 * mrem_h, capture_time=22.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.066 * mrem_h, capture_time=23.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.065 * mrem_h, capture_time=24.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.063 * mrem_h, capture_time=25.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.065 * mrem_h, capture_time=26.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.064 * mrem_h, capture_time=27.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.064 * mrem_h, capture_time=27.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.065 * mrem_h, capture_time=28.0 * s),\n dict(vid=2, distance=esp_dist, rad=0.063 * mrem_h, capture_time=30.0 * s),\n ]\n\n dist0_v2_rows = [\n dict(vid=3, distance=esp_dist, rad=0.012 * mrem_h, capture_time=0.0 * s),\n dict(vid=3, distance=esp_dist, rad=0.011 * mrem_h, capture_time=1.0 * s),\n dict(vid=3, distance=esp_dist, rad=0.013 * mrem_h, capture_time=8.0 * s),\n dict(vid=3, distance=esp_dist, rad=0.013 * mrem_h, capture_time=9.0 * s),\n ]\n\n close_rows = [\n dict(vid=4, distance=0.5 * m, rad=0.013 * mrem_h, capture_time=0.0 * s),\n dict(vid=4, distance=0.5 * m, rad=0.014 * mrem_h, capture_time=5.0 * s),\n dict(vid=4, distance=0.5 * m, rad=0.012 * mrem_h, capture_time=7.0 * s),\n dict(vid=4, distance=0.5 * m, rad=0.011 * mrem_h, capture_time=15.0 * s),\n dict(vid=4, distance=0.5 * m, rad=0.012 * mrem_h, capture_time=16.0 * s),\n ]\n\n mid_rows = [\n dict(vid=5, distance=1.0 * m, rad=0.014 * mrem_h, capture_time=0.0 * s),\n dict(vid=5, distance=1.0 * m, rad=0.015 * mrem_h, capture_time=5.0 * s),\n dict(vid=5, distance=1.0 * m, rad=0.013 * mrem_h, capture_time=10.0 * s),\n ]\n\n far_rows = [\n dict(vid=6, distance=2.0 * m, rad=0.023 * mrem_h, capture_time=0.0 * s),\n dict(vid=6, distance=2.0 * m, rad=0.025 * mrem_h, capture_time=0.1 * s),\n ]\n\n # guess_dist = ureg.parse_expression('0.3 m') # estimate of how far away we are wrt background\n # guess_rows = [\n # dict(vid=9, distance=guess_dist, rad=0.030 * mrem_h, capture_time=0.0 * s),\n # dict(vid=9, distance=guess_dist, rad=0.041 * mrem_h, capture_time=2.0 * s),\n # dict(vid=9, distance=guess_dist, rad=0.051 * mrem_h, capture_time=3.0 * s),\n # ]\n\n rows = dist0_rows + background_rows + dist0_v2_rows + close_rows + mid_rows + far_rows\n # rows += guess_rows\n\n import pandas as pd\n import numpy as np\n table = pd.DataFrame(rows)\n\n # Ensure comparable units\n units = {\n 'rad': mrem_h,\n 'distance': m,\n 'capture_time': s,\n }\n for key, unit in units.items():\n table[key] = table[key].apply(lambda c: c.to(unit).m)\n table['rad'] = table['rad'].astype(float)\n table['distance'] = table['distance'].astype(float)\n\n # Weight each measurement based on the amount of time the measurement was\n # sustained in the video.\n average_rad_rows = []\n for vid, group in table.groupby('vid'):\n from statsmodels.stats.weightstats import DescrStatsW\n weights = (-1 * group['capture_time'].diff(periods=-1).fillna(0)) / group['capture_time'].iloc[-1]\n table.loc[group.index, 'weight'] = weights\n values = group['rad']\n weighted_stats = DescrStatsW(values, weights=weights, ddof=0)\n dists = group['distance'].unique()\n assert len(dists) == 1\n average_rad_rows.append({\n 'vid': vid,\n 'distance': dists[0],\n 'rad_mean': weighted_stats.mean,\n 'rad_std': weighted_stats.std,\n })\n stats_table = pd.DataFrame(average_rad_rows)\n\n bg_row = stats_table.loc[stats_table['distance'].argmax()]\n fg_row = stats_table.loc[stats_table['distance'].argmin()]\n\n # -------------------\n ADD_DUMMY_VALUES = 0\n if ADD_DUMMY_VALUES:\n # Hack: because we don't have enough samples we can fudge the value\n # knowning that the value should be the background radiation in the\n # limit.\n\n dummy_measurements = []\n extra_support = 1\n for idx in range(3, 3 + extra_support):\n dummy_row = {\n 'vid': -idx,\n 'distance': bg_row['distance'] + idx,\n 'rad_mean': bg_row['rad_mean'],\n 'rad_std': 0.01,\n }\n dummy_measurements.append(dummy_row)\n\n # also add an extra value close to the sample\n rad_bg = bg_row['rad_mean']\n rad_above_bg = fg_row['rad_mean'] - rad_bg\n dummy_row = {\n 'vid': -1,\n 'distance': fg_row['distance'] / 2,\n 'rad_mean': rad_bg + (rad_above_bg * 4),\n 'rad_std': 0.5,\n }\n dummy_measurements.append(dummy_row)\n\n # dummy_row = {\n # 'vid': -2,\n # 'distance': fg_row['distance'] / 4,\n # 'rad_mean': rad_bg + (rad_above_bg * 16),\n # }\n # dummy_measurements.append(dummy_row)\n\n dummy_stats = pd.DataFrame(dummy_measurements)\n dummy_stats['weight'] = 0.5\n stats_table['weight'] = 1.0\n stats_table2 = pd.concat([stats_table, dummy_stats]).reset_index(drop=True).sort_values('distance')\n else:\n stats_table2 = stats_table\n # -------------------\n\n import scipy\n scipy.optimize.curve_fit\n\n # Because we know the radiation should follow an inverse square law wrt to\n # distance, we can fit a polynomial of degree 2 (parabola) to interpolate /\n # extrapolate the **inverse** values.\n x = stats_table2['distance'].values\n y = stats_table2['rad_mean'].values\n s = stats_table2['rad_std'].values\n\n # Model the squared falloff directly\n def invsquare(x, a, b):\n return a * (1 / (0.01 + x ** 2)) + b\n # bg_row['rad_mean']\n # Use curve_fit to constrain the first coefficient to be zero\n try:\n coef = scipy.optimize.curve_fit(invsquare, x, y, sigma=s, method='trf')[0]\n except Exception as ex:\n coef = None\n print(f'ex={ex}')\n\n # Also fit one to the raw weighted points as a sanity check\n # inv_poly2 = Polynomial.fit(table['distance'], 1 / table['rad'], w=table['weight'], deg=2)\n\n import kwplot\n sns = kwplot.autosns()\n plt = kwplot.autoplt()\n # ax = sns.boxplot(data=table, x='distance', y='rad', width=0.1)\n\n # Add in points to show each observation\n ax = sns.relplot(x=\"distance\", y=\"rad\", data=table, size=4, color=\".3\",\n linewidth=0, alpha=0.5, palette='deep')\n\n ax = plt.gca()\n ax.set_xlabel('distance from sample ({})'.format(str(units['distance'])))\n ax.set_ylabel('radiation dosage ({})'.format(str(units['rad'])))\n\n max_meters = 10\n\n extrap_x = np.linspace(0, max_meters, 1000)\n if coef is not None:\n extrap_y1 = invsquare(extrap_x, *coef)\n # extrap_y2 = 1 / inv_poly2(extrap_x)\n ax.plot(stats_table2['distance'].values, stats_table2['rad_mean'].values, 'rx')\n ax.plot(stats_table['distance'].values, stats_table['rad_mean'].values, 'bo')\n ax.plot(extrap_x, extrap_y1, '--')\n ax.set_ylim(0.001, 0.1)\n ax.set_yscale('log')\n # ax.plot(extrap_x, extrap_y2, '--')","def update_and_calculate(self, value):\r\n retval = -1\r\n diff = abs(self.ewma - value)\r\n if self.n >= 5: # only calculate meandevs if collected > 5 data pts.\r\n if self.ewmmd > 0:\r\n meandevs = diff/self.ewmmd\r\n else:\r\n meandevs = diff/.00001\r\n retval = meandevs\r\n \r\n # update ewma/ewmmd\r\n self.n += 1\r\n if self.n > 1:\r\n if self.n > 2:\r\n self.ewmmd = (.125*diff) + (.875*self.ewmmd)\r\n else:\r\n self.ewmmd = diff\r\n self.ewma = (.125*value) + (.875*self.ewma)\r\n else:\r\n self.ewma = value\r\n return retval","def avg_data_each_h(nof, lof, x_vel, y_vel, z_vel):\n sx_vel = []\n sy_vel = []\n sz_vel = []\n\n for i in range(lof):\n sx = 0\n sy = 0\n sa = 0\n for j in range(nof):\n sx += x_vel[i + (j * nof)]\n sy += y_vel[i + (j * nof)]\n sa += z_vel[i + (j * nof)]\n\n sx_vel.append(sx)\n sy_vel.append(sy)\n sz_vel.append(sa)\n\n # checks lengths match and then averages them and returns the average velocities\n if len(sx_vel) == len(sy_vel) and len(sx_vel) == len(sz_vel):\n if len(sx_vel) == lof:\n ax_vel = np.array(sx_vel) / nof\n ay_vel = np.array(sy_vel) / nof\n az_vel = np.array(sz_vel) / nof\n\n return ax_vel, ay_vel, az_vel\n else:\n print \"Error: summed velocity array is the wrong length!\"\n else:\n print \"Error: summed velocity data not matching!\"","def msaa(self, factor=2):\n from .detector import bindown\n x, y, data = self.x, self.y, self.data\n data = bindown(data, factor, factor, 'avg')\n self.data = data\n self.x = x[::factor]\n self.y = y[::factor]\n return self","def EstimatedAutocorr(fw, data, pnum, trialnum, marker1, marker2): \n cycle_start = HeelStrike(fw, data, pnum, trialnum, marker1, marker2)\n x = cycle_start[2] \n time = cycle_start[1]\n drop_NA = np.vstack((x, time))\n #print drop_NA.shape, x.shape, y.shape\n drop_NA = drop_NA.T\n x = drop_NA[:,0]\n #x = x[~np.isnan(x).any()]\n \n #n = len(x)\n #var = np.var(x)\n tao = np.correlate(x, x, mode='full')\n # assert np.allclose(r, np.array([(x[:n-k]*x[-(n-k):]).sum() for k in range(n)]))\n #result = r/(var*(np.arange(n, 0, -1)))\n plt.figure(4)\n plt.plot(tao)\n return tao","def preCalibrate(self):\n self._write_enabled = False\n self.start_recording()\n\n origin = (int(self.disp.dispsize[0] / 4), int(self.disp.dispsize[1] / 4))\n size = (int(2 * self.disp.dispsize[0] / 4), int(2 * self.disp.dispsize[1] / 4))\n\n videoFile = os.path.join(c.CALIBVIDEODIR, \"--- cal_movie_1.mov\")\n\n # Initialise a PsychoPy MovieStim\n mov = visual.MovieStim3(self.video_win, videoFile, flipVert=False)\n\n print(\"------------> Pre-calibration process started.\")\n print(\"------------> When correctly positioned press \\'space\\' to start the calibration.\")\n\n while mov.status != visual.FINISHED:\n if not self.gaze:\n continue\n\n self.screen.clear()\n\n # Add the MovieStim to a PyGaze Screen instance.\n self.screen.screen.append(mov)\n\n gaze_sample = copy.copy(self.gaze[-1])\n\n validity_colour = (255, 0, 0)\n\n if gaze_sample['right_gaze_origin_validity'] and gaze_sample['left_gaze_origin_validity']:\n left_validity = 0.15 < gaze_sample['left_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\n right_validity = 0.15 < gaze_sample['right_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\n if left_validity and right_validity:\n validity_colour = (0, 255, 0)\n\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0] + size[0], origin[1]), pw=1)\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0], origin[1] + size[1]), pw=1)\n self.screen.draw_line(colour=validity_colour,\n spos=(origin[0], origin[1] + size[1]),\n epos=(origin[0] + size[0], origin[1] + size[1]),\n pw=1)\n self.screen.draw_line(colour=validity_colour,\n spos=(origin[0] + size[0], origin[1] + size[1]),\n epos=(origin[0] + size[0], origin[1]),\n pw=1)\n\n right_eye, left_eye, distance = None, None, []\n if gaze_sample['right_gaze_origin_validity']:\n distance.append(round(gaze_sample['right_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\n right_pos = gaze_sample['right_gaze_origin_in_trackbox_coordinate_system']\n right_eye = ((1 - right_pos[0]) * size[0] + origin[0], right_pos[1] * size[1] + origin[1])\n self.screen.draw_circle(colour=validity_colour,\n pos=right_eye,\n r=int(self.disp.dispsize[0] / 100),\n pw=5,\n fill=True)\n\n if gaze_sample['left_gaze_origin_validity']:\n distance.append(round(gaze_sample['left_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\n left_pos = gaze_sample['left_gaze_origin_in_trackbox_coordinate_system']\n left_eye = ((1 - left_pos[0]) * size[0] + origin[0], left_pos[1] * size[1] + origin[1])\n self.screen.draw_circle(colour=validity_colour,\n pos=left_eye,\n r=int(self.disp.dispsize[0] / 100),\n pw=5,\n fill=True)\n\n self.screen.draw_text(text=\"Current distance to the eye tracker: {0} cm.\".format(self._mean(distance)),\n pos=(int(self.disp.dispsize[0] / 2), int(self.disp.dispsize[1] * 0.9)),\n colour=(255, 255, 255),\n fontsize=20)\n\n self.disp.fill(self.screen)\n self.disp.show()\n\n key = self._getKeyPress()\n if key == \"space\":\n break\n\n\n\n if mov.status != visual.FINISHED:\n # pause and discard video for the audio to stop as well\n mov.pause()\n self.screen.screen.remove(mov)\n #video_win.close()\n del mov\n self.screen.clear()\n clock.pause(1000)\n return True\n else:\n return False","def estimate_running_each_trial(running_trace, trial_onset, smoothsize=10, presamples=4,\n threshold=3, showfig=False):\n smoothwin = np.ones(smoothsize)/(smoothsize)\n running_trace_smooth = np.convolve(running_trace, smoothwin, mode='same')\n trial_onset_ind = np.where(trial_onset)[0]\n presamples_inds = np.arange(-presamples, 0) + trial_onset_ind[:, np.newaxis]\n pretrial_avg = running_trace_smooth[presamples_inds].mean(axis=1)\n running_each_trial = pretrial_avg > threshold\n if showfig:\n plt.cla()\n plt.plot(running_trace_smooth, '0.8')\n plt.plot(trial_onset_ind, pretrial_avg, 'xg')\n plt.plot(trial_onset_ind, running_each_trial*running_trace_smooth.max(), 'og')\n plt.axhline(threshold, color='k')\n plt.legend(['running_trace_smooth', 'pretrial_avg', 'running_each_trial'],\n loc='upper right')\n plt.show()\n return running_each_trial, running_trace_smooth","def event(self, evt, env):\n\n super(mod_radial_average, self).event(evt, env)\n if (evt.get(\"skip_event\")):\n return\n\n # This module only applies to detectors for which a distance is\n # available.\n distance = cspad_tbx.env_distance(self.address, env, self._detz_offset)\n if distance is None:\n self.nfail += 1\n self.logger.warning(\"event(): no distance, shot skipped\")\n evt.put(skip_event_flag(), \"skip_event\")\n return\n\n # See r17537 of mod_average.py.\n device = cspad_tbx.address_split(self.address)[2]\n if device == 'Cspad':\n pixel_size = cspad_tbx.pixel_size\n saturated_value = cspad_tbx.cspad_saturated_value\n elif device == 'marccd':\n pixel_size = 0.079346\n saturated_value = 2**16 - 1\n elif device == 'Rayonix':\n pixel_size = rayonix_tbx.get_rayonix_pixel_size(self.bin_size)\n saturated_value = rayonix_tbx.rayonix_saturated_value\n\n d = cspad_tbx.dpack(\n active_areas=self.active_areas,\n address=self.address,\n beam_center_x=pixel_size * self.beam_center[0],\n beam_center_y=pixel_size * self.beam_center[1],\n data=self.cspad_img.iround(), # XXX ouch!\n distance=distance,\n pixel_size=pixel_size,\n saturated_value=saturated_value,\n timestamp=self.timestamp,\n wavelength=self.wavelength,\n xtal_target=self.m_xtal_target)\n\n from xfel.command_line.radial_average import run\n args = [\n \"file_path=XTC stream\",\n \"xfel_target=%s\"%self.m_xtal_target,\n \"verbose=False\"\n ]\n\n t = self.timestamp\n s = t[0:4] + t[5:7] + t[8:10] + t[11:13] + t[14:16] + t[17:19] + t[20:23]\n\n if self._dirname is not None:\n dest_path = os.path.join(self._dirname, self._basename + s + \".txt\")\n args.append(\"output_file=%s\"%dest_path)\n\n self.logger.info(\"Calculating radial average for image %s\"%s)\n xvals, results = run(args, d)\n\n evt.put(xvals, \"cctbx.xfel.radial_average.xvals\")\n evt.put(results, \"cctbx.xfel.radial_average.results\")\n\n def get_closest_idx(data, val):\n from scitbx.array_family import flex\n deltas = flex.abs(data - val)\n return flex.first_index(deltas, flex.min(deltas))\n\n if self._two_theta_low is not None:\n i_low = results[get_closest_idx(xvals, self._two_theta_low)]\n evt.put(i_low, \"cctbx.xfel.radial_average.two_theta_low\")\n\n if self._two_theta_high is not None:\n i_high = results[get_closest_idx(xvals, self._two_theta_high)]\n evt.put(i_high, \"cctbx.xfel.radial_average.two_theta_high\")","def running_mean(self,windowlength=3*86400.0,overlap=12*3600.0, plot=True):\r\n \r\n # Make sure that omega is a list\r\n\r\n pt1,pt2 = window_index_time(self.t,windowlength,overlap)\r\n npt = len(pt1)\r\n tmid = []\r\n ymean = np.zeros((npt,))\r\n yrms = np.zeros((npt,))\r\n\r\n ii=-1\r\n for t1,t2 in zip(pt1,pt2):\r\n ii+=1\r\n\r\n ymean[ii] = self.y[t1:t2].mean()\r\n yrms[ii] = crms(self.tsec[t1:t2],self.y[t1:t2]-ymean[ii])\r\n \r\n # Return the mid time point\r\n ind = np.floor(t1 + (t2-t1)/2)\r\n tmid.append(self.t[ind])\r\n \r\n tmid = np.asarray(tmid)\r\n \r\n if plot:\r\n plt.subplot(211)\r\n self.plot()\r\n plt.plot(tmid,ymean,'r')\r\n plt.fill_between(tmid,ymean-yrms,y2=ymean+yrms,color=[0.5,0.5,0.5],alpha=0.5)\r\n plt.legend(('Original Signal','Mean','$\\pm$ RMS'))\r\n \r\n ax=plt.subplot(212)\r\n plt.fill_between(tmid,yrms,alpha=0.7)\r\n plt.xticks(rotation=17)\r\n plt.ylabel('RMS')\r\n ax.set_xlim([self.t[0],self.t[-1]])\r\n \r\n \r\n return tmid, ymean, yrms","def calculate_metrics(self):\n\n # from the roi pixels we calculate the offset from the camera if the car\n # is at middle --> ie. half bottom roi with is 0\n x_center = (self.roi_warped_points[0][0] + \\\n (self.roi_warped_points[1][0] - self.roi_warped_points[0][0]) / 2) * self.xm_per_pix\n\n # calculate the base point (near the car) with respect to the ROI\n base_fitx = self.best_fit[0]*self.roi_warped_points[2][1]**2 + \\\n self.best_fit[1]*self.roi_warped_points[2][1] + \\\n self.best_fit[2]\n\n # calculate the base point for the line in m according to the camera\n # as origin point\n self.line_base_pos = base_fitx * self.xm_per_pix - x_center\n\n # calculate the radius of the curvature by fitting a polynom through\n # the current X and Y points in real world units\n fit_cr = np.polyfit(self.ally * self.ym_per_pix, self.allx * self.xm_per_pix, 2)\n\n self.radius_of_curvature = ((1 + (2*fit_cr[0]*719*self.ym_per_pix + \\\n fit_cr[1])**2)**1.5) / np.absolute(2*fit_cr[0])","def calibrate_file(self, calibration_slope, calibration_offset):\n\n self.data.average_spectrum = (calibration_slope * self.data.average_spectrum \n + calibration_offset)\n\n individual_wavelength = np.zeros(2048)\n individual_slope = np.zeros(2048)\n individual_offset = np.zeros(2048)\n\n for i_wavelength in range(2048):\n individual_wavelength[i_wavelength] = self.data.wavelength[\n i_wavelength * self.header.zero_fill]\n individual_slope[i_wavelength] = calibration_slope[\n i_wavelength * self.header.zero_fill]\n individual_offset[i_wavelength] = calibration_offset[\n i_wavelength * self.header.zero_fill]\n\n index = np.argsort(individual_wavelength)\n individual_wavelength = individual_wavelength[index]\n self.data.individual_wavelength = individual_wavelength\n average_spectrum = self.data.average_spectrum[index]\n\n i_min = np.argmin(abs(individual_wavelength - 8.0))\n i_max = np.argmin(abs(individual_wavelength - 14.0))\n\n for i in range(self.header.number_of_coadds):\n i_center_burst = np.argmax(np.absolute(self.data.interferogram[i]))\n\n size = self.header.interferogram_size\n interferogram_shift = size/2 - i_center_burst\n\n self.data.interferogram[i] = np.roll(self.data.interferogram[i], \n interferogram_shift)\n self.data.interferogram[i] = self.data.interferogram[i][\n size/2-2048:size/2+2048]\n\n window_fn = np.hanning(4096)\n \n spectrum = np.fft.fft(self.data.interferogram[i] * window_fn)\n spectrum = spectrum/3300\n spectrum = individual_slope * np.absolute(spectrum[0:2048]\n ) + individual_offset\n spectrum = spectrum[index]\n\n self.data.spectrum.append(spectrum)","def __init__(self, roi_warped_points):\n\n # was the line detected in the last iteration?\n self.detected = False\n # x values of the last n fits of the line\n self.recent_xfitted = []\n #average x values of the fitted line over the last n iterations\n self.bestx = None\n #polynomial coefficients averaged over the last n iterations\n self.best_fit = [np.array([False])]\n #polinomial coefficients for the last n fits of the lane\n self.recent_fit = []\n #polynomial coefficients for the most recent fit\n self.current_fit = [np.array([False])]\n #radius of curvature of the line in some units\n self.radius_of_curvature = 0\n #distance in meters of vehicle center from the line\n self.line_base_pos = 0\n #difference in fit coefficients between last and new fits\n self.diffs = np.array([0,0,0], dtype='float')\n #x values for detected line pixels\n self.allx = None\n #maximum number of iterations to average\n self.max_n = 10 #25\n\n # roi image points in bird's view space\n self.roi_warped_points = roi_warped_points\n\n #y values for detected line pixels\n self.ally = np.linspace(0, self.roi_warped_points[2][1] - 1, self.roi_warped_points[2][1])\n\n # line base pos is calculated through the roi information\n # the used four point ROI has two points at the bottom that are straight\n # with respect to the bottom - as this points are right next to the lines,\n # they can be translated from pixels into meters with the knowledge of\n # a U.S. highway standard lane - this is an apprximation, but should be\n # good enough for this project\n # U.S. regulations minimum lane width: 3.7m\n self.xm_per_pix = 3.7 / (self.roi_warped_points[1][0] - self.roi_warped_points[0][0])\n\n # each dashed line is 3m long --> about 33m for warped image\n self.ym_per_pix = 33 / (self.roi_warped_points[2][1] - self.roi_warped_points[0][1])","def autoAnalyze(self):\n print(\"Perfoming full automatic analysis...\")\n t1=time.perf_counter()\n self.cleanUp()\n self.figure_rois()\n self.figure_roi_inspect_all()\n self.figure_dGoR_roi(showEach=False,saveAs=self.folderSave+\"/avg.png\")\n self.figure_dGoR_roi(showEach=True,saveAs=self.folderSave+\"/each.png\")\n self.index()\n print(\"analysis completed in %.02f sec\"%(time.perf_counter()-t1))","def data_vis():\n dataroot = 'solar_data.txt'\n debug = False \n diff = False\n X, y = read_data(dataroot, debug, diff)\n\n # First plot the original timeseries\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(y)\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(X[:,0])\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(X[:,1])\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(X[:,2])\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(X[:,3])\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(X[:,4])\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(X[:,5])\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##########################################################################################\n # Plotting the Fourier Transform of the signals\n\n freq = np.fft.fftfreq(len(y), 1*60*60)\n\n fig = plt.figure(figsize=(40,40))\n\n fig.add_subplot(3,3,1)\n plt.plot(freq, np.abs(np.fft.fft(y)))\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\n # plt.show()\n\n fig.add_subplot(3,3,2)\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\n plt.title('Avg Zenith Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,3)\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\n plt.title('Avg Azimuth Angle [degrees]')\n # plt.show()\n\n fig.add_subplot(3,3,4)\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\n # plt.show()\n\n fig.add_subplot(3,3,5)\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\n plt.title('Avg Tower RH [%]')\n # plt.show()\n\n fig.add_subplot(3,3,6)\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\n plt.title('Avg Total Cloud Cover [%]')\n # plt.show()\n\n fig.add_subplot(3,3,7)\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\n # plt.show()\n\n ##################################################################################################\n # Print correlation matrix\n\n df = pd.DataFrame(np.c_[y, X])\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\n f = plt.figure(figsize=(19, 15))\n plt.matshow(df.corr(), fignum=f.number)\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\n cb = plt.colorbar()\n cb.ax.tick_params(labelsize=14)\n plt.title('Correlation Matrix', fontsize=16);\n plt.show()","def make_histogram():\n\n # Create a list to save mean angles and mean poss\n mean_angles = []\n mean_poss = []\n\n # Find the data files (takes all files ending in .txt)\n filenames = glob.glob(\"*.txt\")\n\n for filename in filenames:\n\n # Load the data\n with open(filename, 'rb') as file:\n ellipses = pickle.load(file)\n\n # Find the range where it levitates\n # Plot the angle and the major and minor axes of the elipse\n elFig, (axAx, angAx) = plt.subplots(2, 1, sharex=True)\n axAx.plot([e[1][0] for e in ellipses])\n axAx.plot([e[1][1] for e in ellipses])\n angAx.plot([e[2] for e in ellipses])\n\n axAx.set_ylabel(\"Axis length (μm)\")\n angAx.set_ylabel(\"Angle (°)\")\n angAx.set_xlabel(\"Time (s)\")\n\n axAx.set_title(\"Pick one point when the particle starts to levitate\\nand one when it stops\")\n\n points = plt.ginput(2, timeout=-1)\n plt.close()\n\n if not points:\n continue\n\n start_frame = int(points[0][0])\n end_frame = int(points[1][0])+1\n\n # Angles when it levitates are the ones between start and end frame\n angles = [e[2] for e in ellipses[start_frame:end_frame]]\n\n # Convert the 0-180 span of angles to 0-2 pi\n # This is because it wraps around at 180 rather than 360\n # so the mean needs to reflect this\n #breakpoint()\n rads = np.array(angles) * np.pi / 90\n\n mean_rad = circular_mean(rads)\n\n mean_angle = 90 * mean_rad / np.pi\n\n # Add it to list of mean angles\n mean_angles.append(mean_angle)\n\n # Calculate the mean position\n positions = np.array([e[0] for e in ellipses[start_frame:end_frame]])\n\n mean_pos = np.mean(positions, axis=0)\n\n mean_poss.append(mean_pos)\n\n\n # End for filename in filenames\n\n # Plot histogram\n ax = plt.subplot(projection=\"polar\")\n\n rads = np.array(mean_angles) * np.pi / 90\n bars = ax.hist(rads, bins=72, bottom=0)\n # Set labels\n ax.set_thetagrids(tuple(range(0,360,30)), labels=[f\"{a}°\" for a in range(0, 180, 15)])\n ax.set_rgrids([0, 1, 2, 3])\n ax.set_title(\"Average angle of semi-major axis of ellipse\")\n\n\n fig, posAx = plt.subplots()\n\n \n for p in mean_poss:\n posAx.plot(*p, 'o')\n\n posAx.set_xlabel(r\"$x$-position (μm)\")\n posAx.set_ylabel(r\"$y$-position (μm)\")\n posAx.set_title(\"Average position for the films\")\n plt.show()","def problemOne(self):\n self.hot_volt = self.data['calibration']['hot volt'].tolist()\n self.pitot_vel = self.data['calibration']['pitot vel'].tolist()\n # Create interpolation function of FFT data for finding coefficients\n self.v_hot = np.poly1d(np.array(self.cal_coeffs))\n # Create string to print coefficients on plot\n print_coeffs = 'Curve Coefficients:'\n coeff_index = [4, 3, 2, 1, 0]\n for i in range(0, 5):\n print_coeffs += f'\\n$a_{i}$ = {self.cal_coeffs[coeff_index[i]]}'\n # Create curve fit data to plot\n fit_plot_y = [self.v_hot(j) for j in self.hot_volt]\n # Calculate difference and standard deviation b/w the interpolation curve and experimental data\n difference = []\n for i in self.hot_volt:\n index = self.hot_volt.index(i)\n difference.append(self.pitot_vel[index] - self.v_hot(i))\n std_dev = statistics.stdev(difference)\n print(f'prob one std dev = {std_dev}')\n # Plot velocities vs voltage\n plot_1 = plt.figure(figsize=(8, 8))\n vv = plot_1.add_subplot(1, 1, 1)\n props = dict(boxstyle='round', facecolor='white', alpha=0.2)\n vv.set_xlabel('Hotwire $E_v$ [Volts]', fontsize=14)\n vv.set_ylabel('Velocity [m/s]', fontsize=14)\n vv.grid(linewidth=0.5, color='gray', linestyle='--')\n vv.plot(self.hot_volt, fit_plot_y, color='k', linewidth=1, label='Hotwire Curve Fit')\n vv.scatter(self.hot_volt, self.pitot_vel, color='r', s=15, label='Pitot Exp. Data', marker='o')\n vv.text(0.02, 0.9, print_coeffs, transform=vv.transAxes, fontsize=11, verticalalignment='top', bbox=props)\n vv.legend(loc='upper left')\n plot_1.savefig(os.path.join(os.getcwd(), r'plots\\prob1'))\n plt.draw()","def calibrate(self,(minX,minY,minZ),(maxX,maxY,maxZ),duration = 5,integer = True):\n\t\tt0 = time.time()\n\t\tminXYZ,maxXYZ = [2*31]*3,[-2**31]*3##+- inf...not nice but it will do...\n\t\twhile time.time() - t0 < duration: ## Probably not the best guard\n\t\t\tself.refresh()\n\t\t\tpoints = self.coordinateTracker.getListOfCartesianCoordinates()\n\t\t\tminXYZ = [ min ([minXYZ[i]] + [point[i] for point in points]) for i in [0,1,2] ]\n\t\t\tmaxXYZ = [ max ([maxXYZ[i]] + [point[i] for point in points]) for i in [0,1,2] ]\n\t\tfactor = max([abs(maxXYZ[i] - minXYZ[i]) for i in [0,1,2]])\n\t\t\n\t\tdef scale((x,y,z)):\n\t\t\t## Yeah, I know this /could/ be re-factored.\n\t\t\t## But this is simpler. \n\t\t\tif factor != 0:\n\t\t\t\tx = float(x) - (minXYZ[0]+maxXYZ[0])/2 \n\t\t\t\tx = x/factor\n\t\t\t\tx = x*abs(maxX - minX)\n\t\t\t\tx = x+(maxX + minX)/2\n\t\t\t\n\t\t\t\ty = float(y) - (maxXYZ[1] + minXYZ[1])/2\n\t\t\t\ty = y/factor\n\t\t\t\ty = y*abs(maxY - minY)\n\t\t\t\ty = y+(maxY + minY)/2\n\n\t\t\t\tz = float(z) - (maxXYZ[2]+ minXYZ[2])/2\n\t\t\t\tz = z/factor\n\t\t\t\tz = z*abs(maxZ - minZ)\n\t\t\t\tz = z+(maxZ + minZ)/2\n\t\t\tif integer: return map(int,(x,y,z))\n\t\t\telse: return x,y,z\n\t\tself.scale = scale","def visualize_save_calibration(performance_sigma, cfg, success):\n percentiles = PERCENTILES\n inside_ratio_reference = percentiles[1] - percentiles[0]\n\n baseline = confidence_test_values.pop('baseline')\n sigmas = sorted(confidence_test_values)\n inside_ratios = [\n confidence_test_values[sigma]['inside_ratio'] for sigma in sigmas\n ]\n confidence = xr.Dataset(\n data_vars={\n 'inside_ratio_reference': ((), inside_ratio_reference, {\n 'units': '1'\n }),\n 'inside_ratio': ('sigma', inside_ratios, {\n 'units': '1'\n }),\n 'sigma': ('sigma', sigmas, {\n 'units': '1'\n }),\n })\n\n figure, axes = plt.subplots(figsize=(12, 8))\n axes.plot(sigmas,\n inside_ratios,\n color='k',\n lw=2,\n label='Perfect models inside the {:.0%} range'.format(\n inside_ratio_reference),\n zorder=99)\n axes.axhline(inside_ratio_reference,\n color='k',\n ls='--',\n label='Reference: {:.0%}'.format(inside_ratio_reference))\n axes.axhline(baseline['inside_ratio'],\n color='k',\n ls=':',\n label='Unweighted baseline: {:.0%}'.format(\n baseline['inside_ratio']))\n\n if success:\n axes.axvline(performance_sigma,\n color='k',\n ls='-.',\n label='Selected performance sigma: {:.2f}'.format(\n performance_sigma))\n axes.set_title('Performance sigma calibration')\n else:\n axes.axvline(\n performance_sigma,\n color='gray',\n ls='-.',\n label='Best performance sigma: {:.2f} (set manually to use)'.\n format(performance_sigma))\n axes.set_title('Performance sigma calibration (FAILED)')\n\n # optional: sharpness\n sharpness = xr.concat([\n confidence_test_values[sigma]['percentile_spread'].expand_dims(\n {'sigma': [sigma]}) for sigma in sigmas], dim='sigma')\n sharpness /= baseline['percentile_spread']\n axes.plot(sigmas,\n sharpness.mean('perfect_model_ensemble'),\n color='lightgray',\n label='Spread relative to unweighted (mean & 80% range)')\n axes.fill_between(sigmas,\n *sharpness.quantile((.1, .9), 'perfect_model_ensemble'),\n facecolor='lightgray',\n edgecolor='none',\n alpha=.3)\n axes.axhline(1, color='lightgray', ls='--')\n\n sharpness.attrs['units'] = '1'\n confidence['sharpness'] = sharpness\n\n axes.set_xlim(SIGMA_RANGE)\n axes.set_ylim(0, 1.3)\n axes.set_xlabel('sigma (1)')\n axes.set_ylabel('Ratio (1)')\n\n axes.legend()\n\n filename_plot = get_plot_filename('performance_sigma_calibration', cfg)\n figure.savefig(filename_plot, dpi=300, bbox_inches='tight')\n plt.close(figure)\n\n filename_data = get_diagnostic_filename('performance_sigma_calibration',\n cfg,\n extension='nc')\n confidence.to_netcdf(filename_data)","def get_avg_points(self):\n pass","def gavg(idata):\n\t\n\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\n\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\n\n\treturn ga","def ratio(gb_data, data_depcode, data_ratio_hospitalises,current_date, data_hospitalises, current_date_file, min_value_80p , nbhospitalises_80p) :\n start = time.time()\n fig, ax = plt.subplots(figsize=(12, 8))\n\n plt.title(f\"Ratio of in-hospital deaths to hospitalizations : {current_date}\", fontsize=20)\n plt.ylabel(\"Total number of deceases / Total number of hospitalized\")\n plt.xlabel(\"Total number of hospitalized\")\n\n for i, txt in enumerate(data_depcode):\n if (data_hospitalises[i] > data_hospitalises.max() * 0.20):\n ax.annotate(txt, (data_hospitalises[i], data_ratio_hospitalises[i]), xytext=(data_hospitalises[i] + 20, data_ratio_hospitalises[i])) \n\n plt.axhline(data_ratio_hospitalises.mean(), color='green', linestyle='--', label=f'average death ratio ({data_ratio_hospitalises.mean():.2f}%)')\n\n plt.axvline(min_value_80p, color='pink', linestyle='-', label=f\"80% of the number of hospitalized people in France are on the right side of the line ({nbhospitalises_80p:.0f} hospitalized)\")\n\n ax.scatter(data_hospitalises, data_ratio_hospitalises)\n\n ax.annotate('updated chart',xy=(1, 0), xytext=(-15, 10), fontsize=15,\n xycoords='axes fraction', textcoords = 'offset points',\n bbox=dict(facecolor = 'white', alpha = 0.9),\n horizontalalignment = 'right', verticalalignment = 'bottom')\n\n ax.yaxis.set_major_formatter(mtick.FormatStrFormatter('%.0f%%'))\n plt.legend()\n\n current_date_file = gb_data['date'].max().strftime('%Y%m%d')\n end = time.time()\n print(\"Time spent on ratio plot: {0:.5f} s.\".format(end - start)) \n plt.show()","def plot_average_SA(repetitions, runs):\n\n\ttotalscores = []\n\n\t# for each repetition\n\tfor i in range(repetitions):\n\n\t\t# create empty list\n\t\talgorithm_scores = []\n\n\t\t# create random schedule and perform simulated annealing with geman coolingscheme\n\t\tchambers, allcourses, student_list, schedule = create_schedule()\n\n\t\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, scores = simulated_annealing(geman, runs, chambers, allcourses, student_list, schedule)\n\n\t\t# create random schedule and perform simulated annealing with linear coolingscheme\n\t\tchambers, allcourses, student_list, schedule = create_schedule()\n\t\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, linear_scores = simulated_annealing(linear, runs, chambers, allcourses, student_list, schedule)\n\n\t\t# create random schedule and perform simulated annealing with sigmoidal coolingscheme\n\t\tchambers, allcourses, student_list, schedule = create_schedule()\n\t\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, sigmoidal_scores = simulated_annealing(sigmoidal, runs, chambers, allcourses, student_list, schedule)\n\n\t\t# create random schedule and perform simulated annealing with exponential coolingscheme\n\t\tchambers, allcourses, student_list, schedule = create_schedule()\n\t\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, exponential_scores = simulated_annealing(exponential, runs, chambers, allcourses, student_list, schedule)\n\n\t\t# add scores to alogrithm list\n\t\talgorithm_scores.append([geman_scores, linear_scores, sigmoidal_scores, exponential_scores])\n\n\t\t# add algorithm list to totalscore\n\t\ttotalscores.append(algorithm_scores)\n\n\t# create empty lists for score per coolingscheme\n\tall_geman_scores = []\n\tall_linear_scores = []\n\tall_sigmoidal_scores = []\n\tall_exponential_scores = []\n\n\t# add single scores coolingschem into lists with all scores\n\tfor i in range(repetitions):\n\t\tall_geman_scores.append(totalscores[i][0][0])\n\t\tall_linear_scores.append(totalscores[i][0][1])\n\t\tall_sigmoidal_scores.append(totalscores[i][0][2])\n\t\tall_exponential_scores.append(totalscores[i][0][3])\n\n\t# create empty lists for sorted scores\n\tgeman_sorted_scores = []\n\tlinear_sorted_scores = []\n\tsigmoidal_sorted_scores = []\n\texponential_sorted_scores = []\n\n\t# for each run\n\tfor i in range(runs):\n\n\t\t# create empty lists for selected scores\n\t\tgeman_selected_score = []\n\t\tlinear_selected_score = []\n\t\tsigmoidal_selected_score = []\n\t\texponential_selected_score = []\n\n\t\t# for each repetition\n\t\tfor j in range(repetitions):\n\n\t\t\t# add selected score to all score list of coolingscheme\n\t\t\tgeman_selected_score.append(all_geman_scores[j][i])\n\t\t\tlinear_selected_score.append(all_linear_scores[j][i])\n\t\t\tsigmoidal_selected_score.append(all_sigmoidal_scores[j][i])\n\t\t\texponential_selected_score.append(all_exponential_scores[j][i])\n\n\t\t# add selected scores into sorted score\n\t\tgeman_sorted_scores.append(geman_selected_score)\n\t\tlinear_sorted_scores.append(linear_selected_score)\n\t\tsigmoidal_sorted_scores.append(sigmoidal_selected_score)\n\t\texponential_sorted_scores.append(exponential_selected_score)\n\n\t# calculate average for each sorted scores\n\tgeman_average_scores = []\n\tfor scores in geman_sorted_scores:\n\t\tgeman_average_scores.append(sum(scores)/len(scores))\n\n\tlinear_average_scores = []\n\tfor scores in linear_sorted_scores:\n\t\tlinear_average_scores.append(sum(scores)/len(scores))\n\n\tsigmoidal_average_scores = []\n\tfor scores in sigmoidal_sorted_scores:\n\t\tsigmoidal_average_scores.append(sum(scores)/len(scores))\n\n\texponential_average_scores = []\n\tfor scores in exponential_sorted_scores:\n\t\texponential_average_scores.append(sum(scores)/len(scores))\n\n\t# store average scores in one list\n\taverage_scores = [geman_average_scores, linear_average_scores, sigmoidal_average_scores, exponential_average_scores]\n\n\t# create plot with multiple lines of all coolingschemes\n\tmultiple_simulated_annealing(average_scores)","def calc_stat_values(self):","def calc_perc_reducts():\n #Load RCP2.6 datq\n cubes = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')\n #Get the surface and high level SO2 emissions\n surf_cube = cubes[3][:,0]\n high_cube = cubes[1][:,0]\n cubes = iris.cube.CubeList([surf_cube,high_cube])\n\n for i in range(0,len(cubes)):\n #Add the year and month to the cube and extract for 2009 onwards\n iris.coord_categorisation.add_year(cubes[i],'time',name='year')\n iris.coord_categorisation.add_month(cubes[i],'time',name='month')\n cubes[i] = cubes[i].extract(iris.Constraint(year = lambda y: y >=2009))\n\n #Make the year-on-year reduction rates\n yoy_rates = []\n for cube in cubes:\n #Calculate the global mean timeseries\n cube.coord('latitude').guess_bounds()\n cube.coord('longitude').guess_bounds()\n area_weights = iris.analysis.cartography.area_weights(cube)\n cube_mean = cube.collapsed(['latitude','longitude'],iris.analysis.MEAN,weights=area_weights)\n\n cube_rates = np.ones((cube_mean.shape))\n #Loop over the months and calculate the changes from the previous year\n #Calculate the year on year proportional changes in the global mean\n for i in range(12,cube_mean.shape[0]):\n cube_rates[i] = cube_mean[i].data / cube_mean[(i-12)].data\n\n yoy_rates.append(cube_rates)\n\n return yoy_rates","def compute(self, Rs, D):\n self.Rs = Rs\n self.D = D\n self.M = (self.Rs * c**2 * au) / (2 * G * M_sun)\n print(\"M = %.1e M☉\\t%.2e Kg\" % (self.M, self.M*M_sun))\n print(\"Rs = %s ua\\t%.2e m\" % (self.Rs, self.Rs*au))\n print(\"D = %s ua\\t%.2e m\\n\" % (self.D, self.D*au))\n\n vrai_debut = time.process_time()\n\n\n seen_angle, deviated_angle = self.trajectories()\n\n self.interpolation = self.interpolate(seen_angle, deviated_angle)\n\n if self.display_interpolation is True:\n xmin = np.min(seen_angle)\n xmax = np.max(seen_angle)\n seen_angle_splin = np.linspace(xmin, xmax, 20001)\n deviated_angle_splin = self.interpolation(seen_angle_splin)\n plt.figure('Trajectories interpolation')\n plt.clf()\n plt.title(\"Light deviation interpolation\", va='bottom')\n plt.xlabel('seen angle(°)')\n plt.ylabel('deviated angle(°)')\n plt.plot(seen_angle, deviated_angle, 'o')\n plt.plot(seen_angle_splin, deviated_angle_splin)\n plt.grid()\n #plt.savefig('interpolation.png', dpi=250, bbox_inches='tight')\n plt.draw()\n#\n print(\"last angle\", seen_angle[-1])\n print(\"trajectories time: %.1f\" % (time.process_time()-vrai_debut))\n\n img_matrix_x, img_matrix_y = self.create_matrices()\n\n self.img_matrix_x = img_matrix_x\n self.img_matrix_y = img_matrix_y\n\n self.img2 = self.img_pixels(self.img_debut)\n\n vrai_fin = time.process_time()\n print(\"\\nglobal computing time: %.1f\\n\" % (vrai_fin-vrai_debut))","def average_energy(power,events,borders,eventName):\n event_consider = events[events['eventName']==eventName].reset_index(drop=True)\n average = 0\n i = 0\n count = 0\n minValue = 10000\n maxValue = 0\n minAverage = 10000\n maxAverage = 0 \n while(i<len(event_consider)):\n date = time.mktime(datetime.strptime(event_consider['time'][i], \"%Y-%m-%d %H:%M:%S\").timetuple())\n start = str(datetime.fromtimestamp(date+borders[0]))\n end = str(datetime.fromtimestamp(date+borders[1]))\n values = power[(power['time']>=start)&(power['time']<=end)]['value']\n sum_values = sum(values)\n tot_values = len(values)\n if tot_values>0:\n if values.max() > maxValue:\n maxValue = values.max()\n if values.min() < minValue:\n minValue = values.min()\n if sum_values/tot_values > maxAverage:\n maxAverage = sum_values/tot_values\n if sum_values/tot_values < minAverage:\n minAverage = sum_values/tot_values\n average = average + sum_values/tot_values\n count += 1\n i += 1\n if count>0:\n average = average / count\n print(\"number of\", eventName ,\"in groudtruth and power=\",count)\n print(\"minValue=\",minValue,\"maxValue=\",maxValue)\n print(\"minAverage=\",minAverage,\"maxAverage=\",maxAverage)\n print(\"Final Av=\",average)\n return average\n else:\n print(\"Not values found in the range\")","def avgtr(self):\n return np.diff(self.trtimes).mean()","def calibration(self) -> tuple[int, int, int, int, int]:","def PMTandPiezoPlot(datadir,run,event,gain): \n en = event\n mu = gain\n e = sbc.DataHandling.GetSBCEvent.GetEvent(datadir+'/'+run,en)\n print(e[\"fastDAQ\"].keys())\n cgate = e[\"fastDAQ\"][\"CAMgate\"]\n dcam = np.diff(cgate)\n \n p0=e[\"fastDAQ\"][\"Piezo1\"]\n p1 = e[\"fastDAQ\"][\"Piezo2\"]\n fdt = e[\"fastDAQ\"][\"time\"]\n runreconpath = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/%s/\"%run\n pmtdiffs = []\n diffs = []\n \n camOnTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] < -0.5]\n camOffTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] > 0.5]\n print(len(camOnTimes))\n print(len(camOffTimes))\n \n acousticfilename = runreconpath+\"AcousticAnalysis_%s.bin\"%run\n a = sbc.DataHandling.ReadBinary.ReadBlock(acousticfilename)\n bubt0 = a[\"bubble_t0\"]\n \n pmttracetime = e[\"PMTtraces\"][\"t0_sec\"][:,0]+e[\"PMTtraces\"][\"t0_frac\"][:,0]\n d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\n pmtalign = d[\"PMT_trigt0_sec\"]+d[\"PMT_trigt0_frac\"]\n tracetimes = pmttracetime - pmtalign\n at0 = bubt0[en,0]\n at0_1 = bubt0[en,1]\n \n allxyzfname = \"/pnfs/coupp/persistent/grid_output/SBC-17/output/SimpleXYZ_all.bin\"\n xyzf = sbc.DataHandling.ReadBinary.ReadBlock(allxyzfname)\n indices = [i for i,x in enumerate(xyzf[\"runid\"]) if str(x[0])+\"_\"+str(x[1]) == run]\n xyz_reconstructed = True\n if len(indices) > 0:\n runposreco = {\"ev\":[xyzf[\"ev\"][indices]],\"x\":[xyzf[\"bubX\"][indices]],\n \"y\":[xyzf[\"bubY\"][indices]],\"z\":[xyzf[\"bubZ\"][indices]]}\n z = runposreco[\"z\"][0][int(int(en))]\n else:\n print(\"no handscan?\")\n z = 1.5\n xyz_reconstructed = False\n lag_expected = (-23.387649*z - 261.020495)*1e-6 # fit from other analysis\n t0_expected_p0 = at0 + lag_expected\n t0_expected_p1 = at0_1 + lag_expected\n \n i=0\n candidates = []\n candidate_times=[]\n for t in (tracetimes-at0):\n \n if t<0.2 and t>-0.2:\n lastCamOff = 0\n for k in range(len(camOffTimes)):\n if t+at0 > camOffTimes[k]:\n lastCamOff = camOffTimes[k]\n elif t+at0 < camOffTimes[k]:\n break\n if t+at0-lastCamOff > 25e-6:\n \n pmtdiffs.append(t)\n trace = np.fabs(e[\"PMTtraces\"][\"traces\"][i][0])\n if max(trace) == 128:\n trace = pi.stitchTraces(trace,np.fabs(e[\"PMTtraces\"][\"traces\"][i][1]))\n dt = e[\"PMTtraces\"][\"dt\"][i][0]\n #baseline = np.mean(trace[0:50])\n #trace = trace - baseline\n [phe,n,totInt,pktimes] = pi.SBC_pulse_integrator_bressler(trace,dt)\n \n if phe != None:\n phe /= mu\n candidates.append(phe)\n candidate_times.append(t)\n i+=1\n candidate_phe = 0\n the_index = 0\n i=0\n near_trace_indices = []\n for t in candidate_times:\n if t > -500e-6 and t <0:\n near_trace_indices.append(list(tracetimes-at0).index(t))\n if candidates[i]>candidate_phe:\n candidate_phe = candidates[i]\n the_index = i\n i+=1\n \n if len(candidates) != 0:\n if max(candidates)>0:\n diffs.append(candidate_times[candidates.index(max(candidates))])\n fig,ax1 = plt.subplots()\n ax2 = ax1.twinx()\n ax1.plot(fdt,p0,'b',alpha=0.6, label = 'piezo 0')\n ax1.plot(fdt,p1,'k',alpha=0.2, label= 'piezo 1')\n for i in range(len(candidates)):\n if i == the_index:\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'r',lw=4)\n else:\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'y',lw=4)\n #ax2.plot([min(candidate_times),max(candidate_times)],[0,0],linewidth=2)\n ax1.plot([at0,at0],[-0.5,0.5],'b',linewidth=2, label = 'acoustic t0, p0')\n ax1.plot([at0_1,at0_1],[-0.5,0.5],'k',linewidth=2, label = 'acoustic t0, p1')\n \"\"\"\n if xyz_reconstructed:\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0')\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1')\n else:\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0, center of chamber')\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1, center of chamber')\n \"\"\"\n ax1.plot(fdt,cgate,'c')\n ax1.plot(fdt[:-1],dcam,'m')\n ax2.set_ylabel('pmt signal (phe)',fontsize=20)\n ax1.set_xlabel('time (s)',fontsize=20)\n ax1.set_ylabel('Acoustic signa(V)',fontsize=20)\n ax1.set_ylim([min(p1),max(p1)])\n ax2.set_xlim([-0.1,0.1])\n #ax2.set_ylim([0,5])\n ax1.legend()\n plt.show\n \n for j in near_trace_indices:\n trace = e[\"PMTtraces\"][\"traces\"][j][0]\n dt = e[\"PMTtraces\"][\"dt\"]\n dt_tr = dt[j][0]\n tPMT = np.arange(len(trace))*dt_tr\n plt.figure()\n plt.plot(tPMT,trace)\n plt.xlabel(\"t (s)\")\n plt.ylabel(\"PMT signal\")\n plt.show\n \n plt.figure()\n plt.plot(e[\"fastDAQ\"][\"time\"],e[\"fastDAQ\"][\"VetoCoinc\"])\n plt.ylabel(\"Veto Coincidence signal\",fontsize=18)\n plt.xlabel(\"time (s)\")\n plt.show","def run():\n\n Number_repetitions = 1\n Rate = np.zeros((Number_repetitions,1))\n Rate20 = np.zeros((Number_repetitions,1))\n Penalty20 = np.zeros((Number_repetitions, 1))\n\n # Loop to average\n for idx in np.arange(0,Number_repetitions,1):\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n a = e.create_agent(LearningAgent) # create agent\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0000001, display=True) # create simulator (uses pygame when display=True, if available)\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\n\n sim.run(n_trials=100) # run for a specified number of trials\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\n\n # I've edited the enviroment variable to do the plot creating an completions array\n completions = np.array(e.completions)\n rate = float(completions.sum())/float((len(completions)))\n rate20 = float(completions[-20:].sum())/20\n\n Rate[idx] = rate\n Rate20[idx] = rate20\n\n Wrong = np.array(a.wrong_moves_per_run[-20:]).mean()\n Penalty20[idx] = Wrong\n\n plt.scatter(np.arange(0,len(completions)),completions)\n plt.plot(Wrong)\n plt.xlabel('Trial')\n plt.ylabel('1 = Get in the destination, 0 = did not get')\n plt.title('Reiforcement learning progress')\n plt.legend(['Rate of completion: ' + str(rate) + '. Rate last 20: ' + str(rate20) + '.Mean penalty last 20: ' + str(Wrong)])\n plt.show()\n\n #print 'Accuracy: ' + str(Rate) + '. Mean: ' + str(np.mean(Rate))\n #print 'Mean 20: ' + str(np.mean(Rate20))#'Accuracy 20: ' + str(Rate20) + '. Mean 20: ' + str(np.mean(Rate20))\n #print 'Mean_penalty: ' + str(np.mean(Penalty20))\n\n # Print state table with actions\n #t = 0\n #for state in a.states:\n #print 'State ' + str(state) + '. Best action: ' + str((str(np.argmax(a.QTable[t][:]))))\n #t += 1","def estimate_arpu(x):\n arpu = 0\n if x['mean_luminosity_km2'] > 5:\n # #10 year time horizon\n # for i in range(0, 10):\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\n # arpu += (\n # (20*12) / (1 + 0.03) ** i\n # )\n return 20 * 12 * 10#arpu\n elif x['mean_luminosity_km2'] > 1:\n # for i in range(0, 10):\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\n # arpu += (\n # (5*12) / (1 + 0.03) ** i\n # )\n return 5 * 12 * 10#arpu\n else:\n # for i in range(0, 10):\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\n # arpu += (\n # (2*12) / (1 + 0.03) ** i\n # )\n return 2 * 12 * 10#arpu","def dishlist_avg_cal(n:list)->float:\r\n all_cal = dishlist_cal(n)\r\n return sum(all_cal)/len(all_cal)","def calculate_average_run_accuracy(self):\n overall_true_rate, true_positive_rate, true_negative_rate, false_positive_rate, false_negative_rate, true_positive_rate_cutoff, true_negative_rate_cutoff, \\\n false_positive_rate_cutoff, false_negative_rate_cutoff, unclassified_cutoff, matthews_correlation_coefficient, brier_score, auc_score, fit_time, hmeasure = [0] * 15\n balanced_accuracy_arr = []\n auc_arr = []\n hmeasure_arr = []\n brier_score_arr = []\n fit_time_arr = []\n mcc_arr = []\n true_positive_arr = []\n true_negative_arr = []\n false_positive_arr = []\n false_negative_arr = []\n\n count = 0\n for result_dictionary in self.errors:\n for z in range(len(result_dictionary[\"balanced_accuracy_arr\"])):\n overall_true_rate += result_dictionary[\"balanced_accuracy_arr\"][z]\n true_positive_rate += result_dictionary[\"true_positive_rate_arr\"][z]\n true_negative_rate += result_dictionary[\"true_negative_rate_arr\"][z]\n false_positive_rate += result_dictionary[\"false_positive_rate_arr\"][z]\n false_negative_rate += result_dictionary[\"false_negative_rate_arr\"][z]\n matthews_correlation_coefficient += result_dictionary[\"mcc_arr\"][z]\n auc_score += result_dictionary[\"auc_arr\"][z]\n brier_score += result_dictionary[\"brier_score_arr\"][z]\n fit_time += result_dictionary[\"fit_time_arr\"][z]\n hmeasure += result_dictionary[\"hmeasure_arr\"][z]\n count += 1\n\n true_positive_rate_cutoff += result_dictionary[\"avg_true_positive_rate_with_prob_cutoff\"]\n true_negative_rate_cutoff += result_dictionary[\"avg_true_negative_rate_with_prob_cutoff\"]\n false_positive_rate_cutoff += result_dictionary[\"avg_false_positive_rate_with_prob_cutoff\"]\n false_negative_rate_cutoff += result_dictionary[\"avg_false_negative_rate_with_prob_cutoff\"]\n unclassified_cutoff += result_dictionary[\"avg_false_negative_rate_with_prob_cutoff\"]\n balanced_accuracy_arr += result_dictionary[\"balanced_accuracy_arr\"]\n hmeasure_arr += result_dictionary[\"hmeasure_arr\"]\n auc_arr += result_dictionary[\"auc_arr\"]\n brier_score_arr += result_dictionary[\"brier_score_arr\"]\n fit_time_arr += result_dictionary[\"fit_time_arr\"]\n mcc_arr += result_dictionary[\"mcc_arr\"]\n true_positive_arr += result_dictionary[\"true_positive_rate_arr\"]\n true_negative_arr += result_dictionary[\"true_negative_rate_arr\"]\n false_positive_arr += result_dictionary[\"false_positive_rate_arr\"]\n false_negative_arr += result_dictionary[\"false_negative_rate_arr\"]\n\n avg_run_results = [None] * 31\n avg_run_results[0] = matthews_correlation_coefficient / float(count)\n avg_run_results[1] = brier_score / float(count)\n avg_run_results[2] = overall_true_rate / float(count)\n avg_run_results[3] = true_positive_rate / float(count)\n avg_run_results[4] = true_negative_rate / float(count)\n avg_run_results[5] = false_positive_rate / float(count)\n avg_run_results[6] = false_negative_rate / float(count)\n avg_run_results[7] = true_positive_rate_cutoff / float(len(self.errors))\n avg_run_results[8] = true_negative_rate_cutoff / float(len(self.errors))\n avg_run_results[9] = false_positive_rate_cutoff / float(len(self.errors))\n avg_run_results[10] = false_negative_rate_cutoff / float(len(self.errors))\n avg_run_results[11] = unclassified_cutoff / float(len(self.errors))\n avg_run_results[12] = fit_time / float(count)\n avg_run_results[14] = balanced_accuracy_arr\n avg_run_results[15] = auc_score / float(count)\n avg_run_results[16] = auc_arr\n avg_run_results[17] = brier_score_arr\n avg_run_results[18] = fit_time_arr\n avg_run_results[19] = mcc_arr\n avg_run_results[13] = self.calculate_std_deviation(balanced_accuracy_arr)\n avg_run_results[20] = self.calculate_std_deviation(mcc_arr)\n avg_run_results[21] = self.calculate_std_deviation(brier_score_arr)\n avg_run_results[22] = self.calculate_std_deviation(auc_arr)\n avg_run_results[23] = self.calculate_std_deviation(fit_time_arr)\n avg_run_results[24] = self.calculate_std_deviation(true_positive_arr)\n avg_run_results[25] = self.calculate_std_deviation(true_negative_arr)\n avg_run_results[26] = self.calculate_std_deviation(false_positive_arr)\n avg_run_results[27] = self.calculate_std_deviation(false_negative_arr)\n avg_run_results[28] = hmeasure / float(count)\n avg_run_results[29] = self.calculate_std_deviation(hmeasure_arr)\n avg_run_results[30] = hmeasure_arr\n\n return avg_run_results","def AllFreAverageV(self,):\n \t\tv_array = self.data\n \t\taaverage_v = np.average(v_array[:,1])\n \t\tprint('Whole frequency average group velocity:\\nVw=',aaverage_v/1000,'km/s')\n \t\treturn","def trysavgol(window, order, data, xaxis):\r\n for datum in data:\r\n filt = scipy.signal.savgol_filter(datum,window,order)\r\n f = makeplot(xaxis, [datum, filt],[\"data\",\"filter\"], \"Temperature / $[J/k_B]$\",\\\r\n \"Heat Capacity / $[k_B]$\", plainlines = True)\r\n f.show()\r\n f.savefig(\"savgol.svg\")\r\n Tc = np.mean(xaxis[filt == max(filt)])\r\n print(\"The predicted value of Tc is: \"+str(Tc))","def print_avg():","def extract_avg_charge_time_5(batch,index):\n avg_time = []\n for ind in index:\n cell_no = list(batch.keys())[ind]\n avg_time_ = np.average(batch[cell_no]['summary']['chargetime'][1:6]) #Cycle 2 to cycle 6\n # avg_time.append(avg_time_)\n avg_time.append(log(abs(avg_time_),10))\n avg_time = np.reshape(avg_time,(-1,1))\n return avg_time\n pass"],"string":"[\n \"def photometric_calibration():\\n pass\",\n \"def calibration(self) -> int:\",\n \"def doRun(run=77):\\n r = xanes_analyzeRun.AnalyzeRun(run)\\n r.load()\\n calibs = list(r.results.keys())\\n calibs.sort()\\n p2 = [np.nanmedian(r.results[c].p1, axis=0) for c in calibs]\\n p2 = np.asarray(p2)\\n ref = np.nanmedian(p2, axis=0)\\n # normalize p2\\n p2 = p2 / ref\\n # remove non-flat part\\n _x = np.arange(p2.shape[1], dtype=float)\\n p2 = [s - mc.poly_approximant(_x, s, order=20)(_x) for s in p2]\\n p2 = np.asarray(p2)\\n x = np.asarray([_x for _ in p2])\\n x[p2 > -0.15] = np.nan\\n x[x < 100] = np.nan\\n # below pixel 200 is noise\\n pos = np.nanmean(x, axis=1)\\n fig, ax = plt.subplots(1, 2, sharey=True)\\n xshift = 0.2\\n pcalib = []\\n for icalib, (xi, p2i) in enumerate(zip(x, p2)):\\n ppar = dict(color=myc(icalib))\\n ax[0].plot(p2i + icalib * xshift, _x, \\\"--\\\", lw=1, alpha=0.5, **ppar)\\n ax[0].plot(p2i + icalib * xshift, xi, lw=2, **ppar)\\n pcalib.append(np.nanmedian(xi))\\n ax[1].plot(r.scanpos[icalib], pcalib[icalib], \\\"o\\\", **ppar)\\n polycal = np.polyfit(pcalib, r.scanpos, 1)\\n ax[1].plot(np.polyval(polycal, _x), _x)\\n print(\\\"polynomial calibration\\\", polycal)\",\n \"def take_one_averaged(self):\\n self.na.set_center_frequency(6.160574e9)\\n self.na.set_span(10e6)\\n self.na.set_power(-5, 1)\\n self.na.set_ifbw(1e3)\\n\\n self.na.set_query_timeout(40e3)\\n set_format = self.na.set_format('polar')\\n print \\\"set_format returned: \\\", set_format\\n self.na.set_trigger_source(\\\"manual\\\")\\n self.na.set_averages(10)\\n self.na.set_trigger_average_mode()\\n\\n self.na.clear_averages(channel=1)\\n self.na.trigger_single(channel=1)\\n fpts, xs, ys = self.na.read_data()\\n #\\n plt.figure()\\n plt.plot(fpts, xs)\\n plt.plot(fpts, ys)\\n plt.show()\",\n \"def calibration(self, cal: int, /) -> None:\",\n \"def area_stats(self):\\r\\n x0 = self.ui.x0.value()\\r\\n x1 = self.ui.x1.value()\\r\\n y0 = self.ui.y0.value()\\r\\n y1 = self.ui.y1.value()\\r\\n \\r\\n channel = self.ui.channel_selection.itemData(self.ui.channel_selection.currentIndex())\\r\\n\\r\\n avg = np.average(self.npImg[y0:y1,x0:x1,channel])\\r\\n std = np.std(self.npImg[y0:y1,x0:x1,channel])\\r\\n minimum = np.min(self.npImg[y0:y1,x0:x1,channel])\\r\\n maximum = np.max(self.npImg[y0:y1,x0:x1,channel])\\r\\n \\r\\n n = (max(x1,x0)-min(x1,x0))*(max(y1,y0)-min(y1,y0))\\r\\n\\r\\n \\r\\n logging.info(\\\"### Statistics for area x: {:d} - {:d}; y: {:d} - {:d} ###\\\".format(x0,x1,y0,y1))\\r\\n logging.info(\\\"channel: {!s}\\\".format(self.ui.channel_selection.currentText()))\\r\\n logging.info(\\\"average: {:.3f} +- {:.3f}\\\".format(avg,std/np.sqrt(n)))\\r\\n logging.info(\\\"standard deviation: {:.3f}\\\".format(std))\\r\\n logging.info(\\\"maximum: {:d}\\\".format(maximum)) \\r\\n logging.info(\\\"minimum: {:d}\\\".format(minimum))\\r\\n logging.info(\\\"--------------------------------------------------------------\\\")\",\n \"def calibrate(self):\\n\\t\\tLTOGRIGHT = []\\n\\t\\tLTOGUP = []\\n\\t\\tRTOGRIGHT = []\\n\\t\\tRTOGUP = []\\n\\t\\tstart = time.time()\\n\\t\\tcalibration_time = 5.0\\n\\t\\twhile time.time() - start < calibration_time:\\n\\t\\t\\tevents = pygame.event.get()\\n\\t\\t\\tfor event in events:\\n\\t\\t\\t\\tif event.type == pygame.JOYAXISMOTION:\\n\\t\\t\\t\\t\\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\\n\\t\\t\\t\\t\\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\\n\\t\\t\\t\\t\\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\\n\\t\\t\\t\\t\\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\\n\\n\\t\\t# calibration sets highest value equal to 1.0\\n\\t\\tself.calibration[0] = 1.0/max(LTOGRIGHT)\\n\\t\\tself.calibration[1] = -1.0/min(LTOGRIGHT)\\n\\t\\tself.calibration[2] = -1.0/min(LTOGUP)\\n\\t\\tself.calibration[3] = 1.0/max(LTOGUP)\\n\\t\\tself.calibration[4] = 1.0/max(RTOGRIGHT)\\n\\t\\tself.calibration[5] = -1.0/min(RTOGRIGHT)\\n\\t\\tself.calibration[6] = -1.0/min(RTOGUP)\\n\\t\\tself.calibration[7] = 1.0/max(RTOGUP)\",\n \"def average_ps(self):\\n\\n self.powerspectrum=np.average(self.powerspectra, axis=0)\",\n \"def average( names):\\n\\n rs = radioastronomy.Spectrum() # create input and average structures\\n asum = radioastronomy.Spectrum()\\n nsum = 0\\n\\n # now average coldest data for calibration\\n for filename in names:\\n\\n rs.read_spec_ast(filename)\\n rs.azel2radec() # compute ra,dec from az,el\\n\\n if nsum == 0:\\n asum = copy.deepcopy( rs)\\n firstlon = rs.gallon\\n asum.ydataA = rs.ydataA * rs.durationSec\\n asum.gallat = rs.gallat * rs.durationSec\\n asum.gallon = rs.gallon * rs.durationSec\\n nsum = 1\\n firstutc = rs.utc\\n lastutc = rs.utc\\n else:\\n asum.ydataA = asum.ydataA + (rs.ydataA * rs.durationSec)\\n asum.count = asum.count + rs.count\\n asum.durationSec = asum.durationSec + rs.durationSec\\n # fix wrap of longitudes\\n if abs(rs.gallon - firstlon) > 180:\\n crossZero = True\\n if rs.gallon > firstlon:\\n rs.gallon = rs.gallon - 360.\\n else:\\n rs.gallon = rs.gallon + 360.\\n asum.gallon = asum.gallon + (rs.gallon * rs.durationSec)\\n asum.gallat = asum.gallat + (rs.gallat * rs.durationSec)\\n # keep track of observing time for weighted sum\\n lastutc = rs.utc\\n nsum = nsum + 1\\n #end for all files loop\\n\\n if nsum < 1:\\n print \\\"No acceptable files in average list\\\"\\n else:\\n asum.ydataA = asum.ydataA/float(asum.durationSec)\\n asum.gallon = asum.gallon/float(asum.durationSec)\\n asum.gallat = asum.gallat/float(asum.durationSec)\\n aveutc,duration = radioastronomy.aveutcs( firstutc, lastutc)\\n asum.utc = aveutc\\n if (duration < 1.):\\n print 'hotcold.average: very short average interval: ',duration\\n return nsum, asum\",\n \"def ratio_4_doc(shot, dir, num_probes = 16):\\n # data = [[0] *3 for i in range(num_probes)]\\n # magdata = hdr.getMagData(shot)\\n probe_locs = get_probeLocs_calib_setup(shot)\\n data=hdr.getquikData(shot)\\n time,eastcurrent,westcurrent = loadcurrent(shot)#using eastcurrent\\n ratios = [[0]*3 for i in range(num_probes)]\\n for probe in range(num_probes):\\n ratio =1\\n inverted = False\\n # fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True)\\n B=sp.signal.detrend(cumtrapz(data.unCalibData[dir,probe,:], data.time))\\n plot_time = data.time[:-1]\\n if(np.max(B[2000:6000]) < abs(np.average(B[2000:6000]))):\\n # print(\\\"\\\\ninverted!\\\")\\n inverted = True\\n # B = B* -1\\n # ratio = -1\\n\\n r = probe_locs[probe]\\n max_current = polyPeak_noPlot(time,eastcurrent)\\n # if(np.max(eastcurrent) < -1*(np.min(eastcurrent))):\\n # max_current = -1*np.min(eastcurrent)\\n helmB = helmholtz2(r,max_current)\\n\\n # THis is intentional! I am only using shots where the cmponent is lined\\n # up with the z-direction of the helmholz field\\n # helmB[2] = helmB[2]*-1\\n max_theoretical = np.max(helmB[2])\\n max_measured = polyPeak_noPlot(plot_time, B)\\n\\n\\n ratio = ratio * max_theoretical/max_measured\\n if ratio > 30000 or ratio < -30000:\\n ratio = 0\\n\\n\\n ratios[probe][dir] = ratio\\n # print(\\\"\\\\tRatio is: %f\\\" %(ratio))\\n # if(inverted and ratio <0):\\n # print(\\\"Inverted and ratio reflects that\\\")\\n # elif(not inverted and ratio <0):\\n if probe ==1:\\n print(\\\"\\\\n Ratio: %5f \\\\n\\\\t max_measured: %3f, \\\\n\\\\t max_theoretical: %5f\\\"%(ratio,max_measured,max_theoretical ) )\\n\\n # Compute the median of the non-zero elements\\n # m = np.median(foo[foo > 0])\\n # Assign the median to the zero elements\\n # foo[foo == 0] = m\\n return ratios\",\n \"def applyCal(beam, row, freqs, freqs_cal, cf, T_d_x, T_d_y):\\n \\n P_sys_xx = beam.cols.xx[row].astype('float')\\n xx_on = beam.cols.xx_cal_on[row].astype('float')\\n xx_off = beam.cols.xx_cal_off[row].astype('float')\\n P_on_xx = np.average(extractMid(xx_on))\\n P_off_xx = np.average(extractMid(xx_off))\\n \\n #P_on_xx = fitLine(freqs_cal, xx_on, len(freqs))\\n #P_off_xx = fitLine(freqs_cal, xx_off, len(freqs))\\n\\n P_sys_yy = beam.cols.yy[row].astype('float')\\n yy_on = beam.cols.yy_cal_on[row].astype('float')\\n yy_off = beam.cols.yy_cal_off[row].astype('float')\\n P_on_yy = np.average(extractMid(yy_on))\\n P_off_yy = np.average(extractMid(yy_off))\\n \\n #P_on_yy = fitLine(freqs_cal, yy_on, len(freqs))\\n #P_off_yy = fitLine(freqs_cal, yy_off, len(freqs))\\n\\n \\n T_sys_xx = P_sys_xx / (cf*P_on_xx - cf*P_off_xx) * T_d_x\\n T_sys_yy = P_sys_yy / (cf*P_on_yy - cf*P_off_yy) * T_d_y\\n \\n return T_sys_xx, T_sys_yy\",\n \"def aperture_phot(self,data,x,y,v):\\n r = np.sqrt((x-self.avg_map_fits['Values'][1])**2 + (y-self.avg_map_fits['Values'][3])**2)\\n \\n inner = (r < 8./60.) & np.isfinite(data) \\n outer = (r > 8.5/60.) & (r < 12./60.) & np.isfinite(data)\\n\\n annu = np.nanmedian(data[outer])\\n annu_rms = np.nanstd(data[outer])\\n flux = np.sum(data[inner]) - annu*np.sum(inner)\\n\\n c = 3e8\\n kb=1.38e-23\\n beam = (1./60.*np.pi/180.)**2\\n factor = 2*kb*(v*1e9/c)**2 * beam * 1e26\\n return flux*factor, annu_rms*np.sqrt(np.sum(inner))*factor\",\n \"def average(self, times=2):\\n for i in range(times):\\n self.statistics()\\n global t, avlist\\n length = len(t)\\n avlist.append(t)\\n t = []\\n\\n total_list = []\\n\\n for l in range(length):\\n total_list.append([])\\n\\n for j in range(times):\\n \\\"\\\"\\\"per time\\\"\\\"\\\"\\n for i in range(length):\\n total_list[i].append(avlist[j][i])\\n\\n \\\"\\\"\\\"calculate\\\"\\\"\\\"\\n ylist = []\\n avlist = []\\n for a in total_list:\\n avg = 0\\n for b in a:\\n avg += b\\n ylist.append(avg/times)\\n self.listy = ylist\\n\\n for e in range(self.el[self.re[0]], self.re[1], self.re[2]):\\n self.listx.append(e)\",\n \"def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):\\n ratio_x = 0\\n ratio_y = 0\\n ratio_z = 0\\n # helm_B = [0,0,0]\\n divideby = 0\\n for shot in range(shot_range[0], shot_range[1]+1):\\n print( 'On shot ', day+str(shot), ' for probe ',probe_num)\\n x,y,z, currmax,helmB_new = probe_calib(day+str(shot), probe_num, position_vector,dir)\\n ratio_x = ratio_x + x\\n ratio_y = ratio_y + y\\n ratio_z = ratio_z + z\\n # helm_B = [helm_B[i] + helmB_new[i] for i in len(helmB)]\\n divideby = divideby + 1 #averaging over the number of shots\\n ratio_Bx = ratio_x/divideby\\n ratio_By = ratio_y/divideby\\n ratio_Bz = ratio_z/divideby\\n # helmB = [helm_B]/divideby\\n # print ratio_Bx, ratio_By, ratio_Bz, helmB\\n # print(\\\"ratio_Bx %f, ratio_By %f, ratio_Bz %f, helmB%s\\\"%(ratio_Bx, ratio_By, ratio_Bz, helmB))\\n Bx_sqr =ratio_x**2\\n By_sqr =ratio_y**2\\n Bz_sqr =ratio_z**2\\n B = Bx_sqr + By_sqr+ Bz_sqr\\n norm_factor = np.sqrt(B)\\n ratio_Bx, ratio_By, ratio_Bz = [ratio_Bx, ratio_By, ratio_Bz]/norm_factor\\n\\n return (ratio_Bx, ratio_By, ratio_Bz, norm_factor)\",\n \"def getavgvel(self):\\n if self.total_time:\\n return (6.28)/(self.total_time)\",\n \"def test_plot_average(self):\\n # Unpack the list of baseline-pairs into a Python list\\n blpairs = np.unique(self.uvp.blpair_array)\\n blps = [blp for blp in blpairs]\\n\\n # Plot the spectra averaged over baseline-pairs and times\\n f1 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\\n average_blpairs=True, average_times=True)\\n elements = [(matplotlib.lines.Line2D, 1),]\\n assert axes_contains(f1.axes[0], elements)\\n plt.close(f1)\\n\\n # Average over baseline-pairs but keep the time bins intact\\n f2 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\\n average_blpairs=True, average_times=False)\\n elements = [(matplotlib.lines.Line2D, self.uvp.Ntpairs),]\\n assert axes_contains(f2.axes[0], elements)\\n plt.close(f2)\\n\\n # Average over times, but keep the baseline-pairs separate\\n f3 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\\n average_blpairs=False, average_times=True)\\n elements = [(matplotlib.lines.Line2D, self.uvp.Nblpairs),]\\n assert axes_contains(f3.axes[0], elements)\\n plt.close(f3)\\n\\n # Plot the spectra averaged over baseline-pairs and times, but also\\n # fold the delay axis\\n f4 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\\n average_blpairs=True, average_times=True,\\n fold=True)\\n elements = [(matplotlib.lines.Line2D, 1),]\\n assert axes_contains(f4.axes[0], elements)\\n plt.close(f4)\\n\\n # Plot imaginary part\\n f4 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\\n average_blpairs=False, average_times=True,\\n component='imag')\\n elements = [(matplotlib.lines.Line2D, self.uvp.Nblpairs),]\\n assert axes_contains(f4.axes[0], elements)\\n plt.close(f4)\\n\\n # Plot abs\\n f5 = plot.delay_spectrum(self.uvp, [blps,], spw=0, pol=('xx','xx'),\\n average_blpairs=False, average_times=True,\\n component='abs')\\n elements = [(matplotlib.lines.Line2D, self.uvp.Nblpairs),]\\n assert axes_contains(f4.axes[0], elements)\\n plt.close(f5)\\n\\n # test errorbar plotting w/ markers\\n\\n # bootstrap resample\\n (uvp_avg, _,\\n _) = grouping.bootstrap_resampled_error(self.uvp, time_avg=True,\\n Nsamples=100, normal_std=True,\\n robust_std=False, verbose=False)\\n\\n f6 = plot.delay_spectrum(uvp_avg, uvp_avg.get_blpairs(), spw=0,\\n pol=('xx','xx'), average_blpairs=False,\\n average_times=False,\\n component='real', error='bs_std', lines=False,\\n markers=True)\\n plt.close(f6)\\n\\n # plot errorbar instead of pspec\\n f7 = plot.delay_spectrum(uvp_avg, uvp_avg.get_blpairs(), spw=0,\\n pol=('xx','xx'), average_blpairs=False,\\n average_times=False,\\n component='real', lines=False,\\n markers=True, plot_stats='bs_std')\\n plt.close(f7)\",\n \"def baseline(spectra):\\n\\n return spectra - np.mean(spectra, axis=0)\",\n \"def analysis_dFF_map(self):\\r\\n\\r\\n \\r\\n\\r\\n print ('Starting dF/F analysis:')\\r\\n\\r\\n self.print_image_info()\\r\\n\\r\\n # smoothwin = int(self.imageData.shape[1]/8.)\\r\\n\\r\\n # get the average image and the average of the whole image over time\\r\\n\\r\\n avgimg = np.mean(self.imageData, axis=0) # get mean image for reference later: average across all time\\r\\n\\r\\n \\r\\n\\r\\n mpl.figure(99)\\r\\n\\r\\n mpl.imshow(avgimg, vmin=0, vmax=np.max(np.max(avgimg, axis=0), axis=0))\\r\\n\\r\\n # self.meanimagevalue = np.mean(np.mean(avgimg, axis=1), axis=0)\\r\\n\\r\\n # self.stdimg = np.std(self.imageData, axis= 0) # and standard deviation\\r\\n\\r\\n imgdatasm = scipy.ndimage.filters.gaussian_filter(self.imageData,[0,2,2],order=0,output=None,mode='reflect',cval=0.0,truncate=4.0)\\r\\n # field correction: smooth the average image, subtract it from the imagedata, then add back the mean value\\r\\n avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, 2, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n # avgimgsm = scipy.ndimage.filters.gaussian_filter(avgimg, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n #self.imageData = (self.imageData-avgimgsm)+ self.meanimagevalue\\r\\n\\r\\n mpl.figure(98)\\r\\n mpl.imshow(avgimgsm,vmin=0, vmax=np.max(np.max(avgimgsm, axis=0), axis=0))\\r\\n mpl.figure(97)\\r\\n mpl.imshow(np.mean(imgdatasm,axis=0))\\r\\n self.n_times = self.timebase\\r\\n\\r\\n periodsize = int(self.period*self.framerate)\\r\\n print('periodsize: ',periodsize)\\r\\n\\r\\n # windowsize = int(self.freqperiod*self.framerate) # window size for every response\\r\\n\\r\\n # r = range(0, self.imageData.shape[0], windowsize)\\r\\n\\r\\n sig = np.reshape(imgdatasm, (self.nrepetitions, periodsize, \\r\\n\\r\\n self.imageData.shape[1], self.imageData.shape[2]), order='C')\\r\\n\\r\\n delresp=np.zeros([19,256,256])\\r\\n repback = np.mean(sig[:,1:4,:,:],axis=1)\\r\\n resp = np.mean(sig[:,5:9,:,:],axis=1)\\r\\n for counter in range(19):\\r\\n delresp[counter,:,:]=(resp[counter,:,:]-repback[counter,:,:])/repback[counter,:,:]\\r\\n quot=np.mean(delresp,axis=0)\\r\\n quot=-quot\\r\\n print ('shape of quot: ', np.shape(quot))\\r\\n # quot=(resp-repback)/repback\\r\\n # quot[quot>0]=0\\r\\n # quot=-1000*quot\\r\\n\\r\\n mpl.figure(7)\\r\\n mpl.imshow(quot,cmap=mpl.cm.binary)\\r\\n mpl.colorbar()\\r\\n\\r\\n quotsm = scipy.ndimage.filters.gaussian_filter(quot, 3, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n mpl.figure(8)\\r\\n mpl.imshow(quotsm,cmap=mpl.cm.binary)\\r\\n mpl.colorbar()\\r\\n \\r\\n # bl = np.mean(sig[:, range(0, sig.shape[1], windowsize), :, :], axis=0)\\r\\n\\r\\n # bl = scipy.ndimage.filters.gaussian_filter(bl, smoothwin, order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n\\r\\n\\r\\n # print (' windowsize: ', windowsize)\\r\\n\\r\\n # print (' periodsize: ', periodsize)\\r\\n # mc = matplotlib.cm\\r\\n\\r\\n # only use sequential maps here\\r\\n\\r\\n # clist = [mc.Reds, mc.YlOrBr, mc.Oranges, mc.Greens, mc.GnBu, mc.Blues, mc.RdPu, mc.Purples,mc.Reds,mc.Greens,mc.Blues,mc.Reds,mc.Reds,mc.Reds,mc.Reds]\\r\\n # clist2 = ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet', 'black','red','purple','green','blue','red','red','red','red']\\r\\n\\r\\n cs = {}\\r\\n\\r\\n # sigd = np.zeros((bl.shape[0], sig.shape[2], sig.shape[3]))\\r\\n# \\r\\n # localmax = {}\\r\\n\\r\\n # sigmax = 0.\\r\\n# \\r\\n # kernel = np.ones((5, 5))\\r\\n\\r\\n # psf = kernel / np.sum(kernel)\\r\\n\\r\\n # compute dF/F, and get maximum over all frequencies\\r\\n\\r\\n print (' sig shape: ', sig.shape)\\r\\n\\r\\n # print (' bl shape: ', bl.shape)\\r\\n\\r\\n # smax = np.zeros(bl.shape[0])\\r\\n\\r\\n # for i in range(bl.shape[0]):\\r\\n\\r\\n # sigd[i] = (np.mean(np.max(sig[:,range(i*windowsize, i*windowsize+windowsize),:,:], axis=0), axis=0) - bl[i,:,:])/bl[i,:,:]\\r\\n\\r\\n # sigd[i] = sigd[i]**2.0\\r\\n\\r\\n # smooth\\r\\n\\r\\n #sigd[i] = scipy.ndimage.filters.gaussian_filter(sigd[i], 1., order=0, output=None, mode='reflect', cval=0.0, truncate=4.0)\\r\\n\\r\\n # deconvolve\\r\\n\\r\\n # sigd[i] = restoration.richardson_lucy(sigd[i], psf, 5)\\r\\n\\r\\n# sm = sigd[i].max().max()\\r\\n\\r\\n# if sm > sigmax:\\r\\n\\r\\n# sigmax = sm\\r\\n\\r\\n# smax[i] = sm\\r\\n\\r\\n# print( ' i, sm: ', i, sm)\\r\\n\\r\\n# # now process for display\\r\\n\\r\\n# print (' sigd shape: ', sigd.shape)\\r\\n\\r\\n# wdat = np.mean(sig, axis=0)\\r\\n\\r\\n# wds = wdat.shape\\r\\n\\r\\n# print('wdat shape: ', wds)\\r\\n\\r\\n# # print (range(int(wds[1]/2.), int(3.*wds[1]/4.)), range(int(wds[2]/2.), int(3.*wds[2]/4.)))\\r\\n\\r\\n# print( 'reduced shape: ', wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))].shape)\\r\\n\\r\\n# wp = wdat[:,range(int(wds[1]/2.),int(3.*wds[1]/4.)),:][:,:,range(int(wds[2]/2.), int(3.*wds[2]/4.))]\\r\\n\\r\\n# wp = np.mean(np.mean(wdat, axis=1), axis=1)\\r\\n\\r\\n# mpl.figure(1)\\r\\n\\r\\n# mpl.plot(np.linspace(0., len(wp)*1./self.framerate, num=len(wp)), wp)\\r\\n\\r\\n\\r\\n\\r\\n# mpl.figure(2)\\r\\n\\r\\n# for i in range(sigd.shape[0]):\\r\\n\\r\\n# sigd[i][sigd[i] < self.threshold*sigmax] = 0.\\r\\n\\r\\n# # find center of mass of areas above threshold\\r\\n\\r\\n# # mass = sigd[i].copy()\\r\\n\\r\\n# # mass[sigd[i] > 0.] = 1.\\r\\n\\r\\n# # structuring_element = [[0,1,0],[1,1,1],[0,1,0]]\\r\\n\\r\\n# # segmentation, segments = scipy.ndimage.label(mass, structuring_element)\\r\\n\\r\\n# # coords = scipy.ndimage.center_of_mass(sigd[i], segmentation, range(1,segments+1))\\r\\n\\r\\n# # xcoords = np.array([x[1] for x in coords])\\r\\n\\r\\n# # ycoords = np.array([x[0] for x in coords])\\r\\n\\r\\n# # cs[i] = (xcoords, ycoords)\\r\\n\\r\\n\\r\\n\\r\\n# # Calculating local maxima\\r\\n\\r\\n# lm = skif.peak_local_max(sigd[i], min_distance=2, threshold_rel=0.25, exclude_border=False, \\r\\n\\r\\n# indices=True, num_peaks=10, footprint=None, labels=None)\\r\\n\\r\\n# localmax[i] = [(m[0], m[1], sigd[i][(m[0], m[1])]) for m in lm]\\r\\n\\r\\n# # print ('i, local max: ',i, localmax)\\r\\n\\r\\n# mpl.subplot(5,5,i+1)\\r\\n# print ('shape of sigd: ',[np.shape(sigd),i])\\r\\n\\r\\n# imga1 = mpl.imshow(sigd[i], cmap=clist[i], vmin=0, origin='lower')\\r\\n\\r\\n# if len(localmax[i]) > 0:\\r\\n\\r\\n# max_fr = np.max([m[2] for m in localmax[i]])\\r\\n\\r\\n# else:\\r\\n\\r\\n# continue\\r\\n\\r\\n# scattersize = 30.\\r\\n\\r\\n# for k, lm in enumerate(localmax[i]):\\r\\n\\r\\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], edgecolors='k',\\r\\n\\r\\n# s=scattersize*lm[2]/max_fr, linewidths=0.125, alpha=0.5)\\r\\n\\r\\n# mpl.subplot(6,5,i+15+1)\\r\\n\\r\\n# wr = range(i*windowsize, i*windowsize+windowsize)\\r\\n\\r\\n# # print (' wr: len, min max: ', len(wr), min(wr), max(wr))\\r\\n\\r\\n# wmax = 0.\\r\\n\\r\\n# for lmax in localmax[i]: # was xcoords\\r\\n\\r\\n# wave = wdat[wr, lmax[0],lmax[1]]\\r\\n\\r\\n# wdff = (wave-wave[0])/wave[0]\\r\\n\\r\\n# if np.max(wdff) > wmax:\\r\\n\\r\\n# wmax = np.max(wdff)\\r\\n\\r\\n# mpl.plot(np.linspace(0., len(wave)*1./self.framerate, num=len(wave)),\\r\\n\\r\\n# wdff, color=clist2[i])\\r\\n\\r\\n# mpl.ylim(-0.1*wmax, wmax)\\r\\n\\r\\n# fig = mpl.figure(3)\\r\\n\\r\\n# for i in range(sigd.shape[0]):\\r\\n\\r\\n# if len(localmax[i]) == 0:\\r\\n\\r\\n# continue\\r\\n\\r\\n# max_fr = np.max([m[2] for m in localmax[i]])\\r\\n\\r\\n# for lm in localmax[i]:\\r\\n\\r\\n# mpl.scatter(lm[1], lm[0], marker='o', c=clist2[i], \\r\\n\\r\\n# s=scattersize*lm[2]/max_fr, alpha=0.5, edgecolors='k')\\r\\n\\r\\n# mpl.ylim(0, sigd.shape[2])\\r\\n\\r\\n# mpl.xlim(0, sigd.shape[1])\\r\\n\\r\\n# mpl.axis('equal')\\r\\n\\r\\n mpl.show()\\r\\n\\r\\n print (' DF/F analysis finished.\\\\n')\",\n \"def averageTime(self):\\n \\n pass\",\n \"def investigate4DRepeatability():\\n parentdir = '/home/rallured/Dropbox/Interferometer/SolarBFlat/Repeatability/'\\n avgs = [1,2,4,8,16,32]\\n\\n #Temporal with fringes tilted\\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTiltTemporal*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\\n #Make progressive averaging plot\\n plt.figure('TemporalTiltedFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Temporal,Tilted')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n reptemptilt = d[-1]-d[-2]\\n figtemptilt = d[-1]\\n\\n #Dynamic with fringes tilted\\n fn = glob.glob(parentdir+'Tilt/17*RepeatabilityTilt_*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = [met.readFlatScript(fi.split('.')[0])[0] for fi in fn]\\n #Make progressive averaging plot\\n plt.figure('DynamicTiltedFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Dynamic,Tilted')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n repdyntilt = d[-1]-d[-2]\\n figdyntilt = d[-1]\\n \\n #Temporal with fringes nulled\\n fn = glob.glob(parentdir+'Nulled/17*.bin')\\n fn.sort()\\n dx = met.readFlatScript(fn[0].split('.')[0])[1]\\n d = np.array([met.readFlatScript(fi.split('.')[0])[0] for fi in fn])\\n #Make progressive averaging plot\\n plt.figure('TemporalNulledFigure')\\n for i in np.arange(6)*2:\\n f,p = fourier.meanPSD(d[i],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(avgs[i/2]))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Temporal,Nulled')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n reptempnull = d[-1]-d[-2]\\n figtempnull = d[-1]\\n \\n #Dynamic with fringes nulled\\n d = pyfits.getdata('/home/rallured/Dropbox/Interferometer/'\\n 'SolarBFlat/Repeatability/'\\n 'Nulled/170103_Processed.fits')\\n rep = np.array([d[i,0]-d[i,1] for i in range(32)])\\n #Make progressive averaging plot\\n plt.figure('DynamicNulledFigure')\\n for i in [0,1,3,7,15,31]:\\n f,p = fourier.meanPSD(d[i,0],win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label=str(i+1))\\n plt.legend(loc='lower left')\\n plt.title('Solar B PSD - Dynamic,Nulled')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n #Get repeatability\\n repdynnull = d[-1][0]-d[-1][1]\\n figdynnull = d[-1][0]\\n\\n #Make comparative repeatability plots with 32 averages\\n plt.figure('CompareRepeatability')\\n f,p = fourier.meanPSD(repdynnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\\n f,p = fourier.meanPSD(repdyntilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\\n f,p = fourier.meanPSD(reptemptilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\\n f,p = fourier.meanPSD(reptempnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\\n plt.legend(loc='lower left')\\n plt.title('Solar B Repeatability - 32 Averages')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n\\n #Make comparative figure plots with 32 averages\\n plt.figure('CompareFigure')\\n f,p = fourier.meanPSD(figdynnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Nulled')\\n f,p = fourier.meanPSD(figdyntilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Dynamic,Tilted')\\n f,p = fourier.meanPSD(figtemptilt,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Tilted')\\n f,p = fourier.meanPSD(figtempnull,win=np.hanning,dx=dx,irregular=True,\\\\\\n minpx=200)\\n plt.loglog(f,p/f[0],label='Temporal,Nulled')\\n plt.legend(loc='lower left')\\n plt.title('Solar B Figure - 32 Averages')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n\\n #Make parroting repeatability plots\\n fig = plt.figure('Parroting')\\n fig.add_subplot(2,2,1)\\n plt.imshow(repdyntilt)\\n plt.title('Dynamic Repeatability')\\n plt.colorbar()\\n fig.add_subplot(2,2,2)\\n plt.imshow(reptemptilt)\\n plt.title('Temporal Repeatability')\\n plt.colorbar()\\n fig.add_subplot(2,2,3)\\n res = legendre2d(repdyntilt,xo=3,yo=3)[0]\\n plt.imshow(repdyntilt-res)\\n plt.title('Dynamic Repeatability Filtered')\\n plt.colorbar()\\n fig.add_subplot(2,2,4)\\n res = legendre2d(reptemptilt,xo=3,yo=3)[0]\\n plt.imshow(reptemptilt-res)\\n plt.title('Temporal Repeatability Filtered')\\n plt.colorbar()\",\n \"def _doCalibration(self):\\n self._cmdCalibration(2)\",\n \"def calc_calories(gpx_track, wt = 175, activity='Run'):\",\n \"def flatNoiseCGH():\\n #Get data\\n wdir = '/home/rallured/Dropbox/AXRO/Metrology/NoiseStudy/FlatMeasurements/'\\n d1,dx1 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas1.fits')\\n d2,dx2 = met.read4DFits(wdir+'161205_RefFlat_Avg8_Meas2.fits')\\n p1,px1 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas1.fits')\\n p2,px2 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestPitch_Meas2.fits')\\n p3,px3 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas1.fits')\\n p4,px4 = met.read4DFits(wdir+'161205_RefFlat_ParrotingTestRoll_Meas2.fits')\\n\\n #Construct baseline power spectra\\n f1,pow1 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1)\\n f2,pow2 = fourier.meanPSD(d1-d2,win=np.hanning,dx=dx1,axis=1)\\n \\n #Construct parroted power spectra\\n f3,pow3 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx1)\\n f4,pow4 = fourier.meanPSD(p1-p2,win=np.hanning,dx=dx2,axis=1)\\n f5,pow5 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx1)\\n f6,pow6 = fourier.meanPSD(p3-p4,win=np.hanning,dx=dx2,axis=1)\\n\\n #Plot\\n plt.loglog(f1,pow1/f1[0],label='Axial Baseline')\\n plt.loglog(f2,pow2/f2[0],label='Azimuthal Baseline')\\n plt.loglog(f3,pow3/f3[0],label='Pitch Axial')\\n plt.loglog(f4,pow4/f4[0],label='Pitch Azimuthal')\\n plt.loglog(f5,pow5/f5[0],label='Roll Axial')\\n plt.loglog(f6,pow6/f6[0],label='Roll Azimuthal')\\n plt.title('Residual Fringe Repeatability Impact')\\n plt.xlabel('Frequency (1/mm)')\\n plt.ylabel('Power ($\\\\mu$m$^2$ mm)')\\n plt.grid()\\n plt.legend(loc='lower left')\\n\\n return f1,pow1\",\n \"def calibrate(cap, location):\\n\\n #Poisition and size of sensor\\n [x, y, h, w] = location\\n\\n #show square to user and wait for key\\n print(\\\"please, step away to clear the blue square displayed on screen and press q to continue\\\")\\n while True:\\n ret, frame = cap.read()\\n cv2.namedWindow('Calibrate',cv2.WINDOW_NORMAL)\\n show = cv2.rectangle(frame, (x,y), (x+w,y+h), (255, 0, 0) , 5)\\n cv2.imshow('Calibrate', show)\\n key = cv2.waitKey(1)\\n if key == ord('q'):\\n break\\n\\n #get first image, process and define window previous for iteration\\n ret, frame = cap.read()\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n frame = cv2.GaussianBlur(frame, (7,7), 0)\\n previous = frame[y:y+w,x:x+h]\\n\\n #set parameters for mean value of sensor, kernel of erode function,\\n sampleNbMean = 50\\n xi = np.empty((0, sampleNbMean))\\n kernel = np.ones((5,5), np.uint8)\\n\\n #iterate over each frame until sample number\\n for iteration in range(sampleNbMean):\\n\\n # Capture frame, draw the window and display to the user\\n ret, frame = cap.read()\\n # Image operation\\n frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\\n frame = cv2.GaussianBlur(frame, (7,7), 0)\\n\\n #get present window\\n present = frame[y:y+w,x:x+h]\\n\\n #add sample for mean, add diference of window with prieviuos\\n xi = np.append(xi,\\n np.sum(\\n cv2.erode(\\n cv2.bitwise_xor(present,previous), kernel, iterations=1)))\\n\\n #present image becomes previous before steping into next image\\n previous = present\\n\\n #mean\\n mean = np.sum(xi)/len(xi)\\n\\n #sigma\\n sum = 0\\n for sample in xi:\\n sum += np.power(sample - mean, 2)\\n sigma = np.sqrt(sum/len(xi))\\n\\n #close window\\n cv2.destroyWindow('Calibrate')\\n\\n return mean, sigma\",\n \"def fiducial_evolution():\\n \\n # fiducial model\\n wangle = 180*u.deg\\n pk = pickle.load(open('../data/gd1_fiducial.pkl', 'rb'))\\n x = pk['x'].to(u.kpc)\\n xorig = x[:2]\\n \\n plt.close()\\n fig, ax = plt.subplots(1,1,figsize=(6,6))\\n \\n plt.sca(ax)\\n \\n Nsnap = 8\\n times = np.linspace(0,0.5,Nsnap)[::-1]\\n angles = np.linspace(0,322,Nsnap)[::-1]*u.deg\\n\\n for e, t in enumerate(times):\\n c = mpl.cm.Blues(0.05+0.85*(Nsnap-e)/Nsnap)\\n #a = 0.5 + 0.5*(Nsnap-e)/Nsnap\\n \\n pk = pickle.load(open('../data/gd1_fiducial_t{:.4f}.pkl'.format(t), 'rb'))\\n x = pk['x'].to(u.kpc)\\n x_, y_ = x[0], x[1]\\n \\n plt.plot(x_[120:-120], y_[120:-120], '.', color=c, ms=10, zorder=Nsnap-e, rasterized=False)\\n \\n xt = 24*np.cos(angles[e]+90*u.deg)\\n yt = 24*np.sin(angles[e]+90*u.deg)\\n if e<Nsnap-1:\\n txt = plt.text(xt, yt, '+ {:.2f} Gyr'.format(t), va='center', ha='center', fontsize='small', color='0.2', rotation=(angles[e]).value, zorder=10)\\n txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none'))\\n \\n plt.text(0, 24, 'Flyby', va='center', ha='center', fontsize='small', color='0.2')\\n\\n lim = 27\\n plt.xlim(-lim,lim)\\n plt.ylim(-lim,lim)\\n plt.gca().set_aspect('equal')\\n \\n plt.xlabel('x [kpc]')\\n plt.ylabel('y [kpc]')\\n \\n plt.tight_layout()\\n plt.savefig('../plots/loop_evolution.pdf')\",\n \"def plot_calibration(df, x_input = \\\"Mean Predicted Avg\\\",\\n y_input = \\\"Empirical Probability\\\",\\n x_name=\\\"Mean Predicted\\\",\\n y_name=\\\"Empirical Probability\\\",\\n method_order = METHOD_ORDER, \\n avg_x = False):\\n\\n methods = df['method_name']\\n uniq_methods = pd.unique(methods)\\n method_order = [j for j in METHOD_ORDER if j in uniq_methods]\\n method_df = []\\n\\n if avg_x: \\n df_copy = df.copy()\\n new_list = [0]\\n new_x_map = {}\\n for method in uniq_methods: \\n temp_vals = df[df['method_name'] == method][x_input]\\n new_ar = np.vstack(temp_vals)\\n new_ar = np.nanmean(new_ar, 0) # avg columnwise\\n new_x_map[method] = new_ar\\n df_copy[x_input] = [new_x_map[method] for method in methods]\\n df = df_copy\\n\\n x, y = df[x_input].values, df[y_input].values\\n\\n\\n method_df = [{x_name : xx, y_name : yy, \\\"Method\\\" : method}\\n for x_i, y_i, method in zip(x, y, methods)\\n for xx,yy in zip(x_i,y_i)]\\n method_df = pd.DataFrame(method_df)\\n sns.lineplot(x=x_name, y=y_name, hue=\\\"Method\\\", alpha=0.8,\\n hue_order=method_order,\\n data=method_df,\\n palette = METHOD_COLORS)\\n x = np.linspace(0,1,100)\\n plt.plot(x, x, linestyle='--', color=\\\"black\\\")\",\n \"def calculate(self):\\n self.results['max'] = numpy.max(self.data)\\n self.results['min'] = numpy.min(self.data)\\n if self.type == 0:\\n self.group_discrete_data()\\n if self.type == 1:\\n self.group_continuous_data()\\n\\n self.results['arithAvg'] = self.average([self.data[i] * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences)\\n self.results['quadAvg'] = math.sqrt(\\n self.average([(self.data[i] * self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences))\\n if self.results['min'] > 0:\\n self.results['geoAvg'] = math.exp(\\n self.average([numpy.log(self.data[i]) * self.occurrences[i] for i in range(len(self.data))],\\n self.totalOccurrences))\\n self.results['harmAvg'] = 1 / self.average(\\n [(self.occurrences[i] / self.data[i]) for i in range(len(self.data))],\\n self.totalOccurrences)\\n else:\\n self.results['geoAvg'] = self.results['harmAvg'] = \\\"N/A\\\"\\n self.results['momentsR'] = self.moments(self.data, self.occurrences, 4)\\n self.results['centralMomentsR'] = self.moments([(i - self.results['arithAvg']) for i in self.data],\\n self.occurrences, 4)\\n self.results['std'] = self.average(\\n [self.occurrences[i] * abs(self.data[i] - self.results['arithAvg']) for i in range(len(self.data))],\\n self.totalOccurrences)\",\n \"def compare_averages_shell_pspec_dft():\\n\\n select_radius = 5. #degrees\\n\\n Nside=256\\n Npix = 12 * Nside**2\\n Omega = 4*np.pi/float(Npix)\\n\\n Nfreq = 100\\n freqs = np.linspace(167.0, 177.0, Nfreq)\\n dnu = np.diff(freqs)[0]\\n Z = 1420/freqs - 1.\\n\\n sig = 2.0\\n mu = 0.0\\n shell = np.random.normal(mu, sig, (Npix, Nfreq))\\n\\n dV = comoving_voxel_volume(Z[Nfreq/2], dnu, Omega)\\n variances = []\\n means = []\\n pks = []\\n\\n gs = gridspec.GridSpec(2, 3)\\n fig = pl.figure()\\n\\n ax0 = pl.subplot(gs[0, 0:2])\\n ax1 = pl.subplot(gs[1, 0])\\n ax3 = pl.subplot(gs[1, 1])\\n ax2 = pl.subplot(gs[:, 2])\\n\\n steps = range(10,110,10)\\n vmin,vmax = min(steps),max(steps)\\n normalize = mcolors.Normalize(vmin=vmin, vmax=vmax)\\n colormap = cm.viridis\\n\\n for n in steps:\\n Nkbins = 100\\n kbins, pk = pspec_funcs.shell_project_pspec(shell, Nside, select_radius, freqs=freqs, Nkbins=Nkbins, N_sections=n, cosmo=True, method='dft', error=False)\\n variances.append(np.var(pk[0:Nkbins-5]))\\n means.append(np.mean(pk[0:Nkbins-5]))\\n pks.append(pk)\\n ax0.plot(kbins, pk, label=str(n), color=colormap(normalize(n)))\\n\\n ax0.axhline(y=dV*sig**2, color='k', lw=2.0)\\n# ax0.legend()\\n scalarmappable = cm.ScalarMappable(norm=normalize, cmap=colormap)\\n scalarmappable.set_array(steps)\\n fig.colorbar(scalarmappable,label=r'Number of snapshots', ax=ax0)\\n ax0.set_ylabel(r\\\"P(k) [mK$^2$ Mpc$^{3}]$\\\")\\n ax0.set_xlabel(r\\\"k [Mpc$^{-1}]$\\\")\\n ax1.plot(steps, np.array(variances), label=\\\"Variance\\\")\\n ax1.set_ylabel(r\\\"Variance(P(k)) [mK$^4$ Mpc$^{6}]$\\\")\\n ax1.set_xlabel(u\\\"Number of 5° snapshots\\\")\\n ax3.plot(steps, means, label=\\\"Mean\\\")\\n ax3.set_ylabel(r\\\"Mean(P(k)) [mK$^2$ Mpc$^{3}]$\\\")\\n ax3.set_xlabel(u\\\"Number of 5° snapshots\\\")\\n ax1.legend()\\n ax3.legend()\\n im = ax2.imshow(np.array(pks)[:,0:Nkbins-5], aspect='auto')#, norm=mcolors.LogNorm())\\n fig.colorbar(im, ax=ax2)\\n print('Fractional deviation: ', np.mean(np.abs(pk - dV*sig**2)))\\n pl.show()\",\n \"def updatefig(*args):\\n p1.set_array(turn(grid))\\n p2.set_data(tally['time'], tally['sickos'])\\n p3.set_data(tally['time'], tally['immune'])\\n p4.set_data(tally['time'], tally['dead'])\\n ax2.set_xlim(0, max(tally['time']))\\n # ax2.set_ylim(0, max(max(sickos), max(immune)))\\n # End sim if the disease is gone\\n if tally['sickos'][-1] == 0:\\n ani.event_source.stop()\\n end_time = time.process_time()\\n show_summary()\\n print(\\\"Process time:\\\", end_time - start_time)\\n return p1, p2, p3, p4,\",\n \"def read_calibrated(self):\\n\\n self.read_sensors()\\n\\n print(\\\"uncalibrated readings\\\")\\n self.print_sensor_values(self.sensorValues)\\n\\n for i in range(0, self.NUM_SENSORS):\\n denominator = self.calibratedMax[i] - self.calibratedMin[i]\\n val = 0\\n if denominator != 0:\\n val = (self.sensorValues[i] - self.calibratedMin[i]) * 1000 / denominator\\n if val < 0:\\n val = 0\\n elif val > 1000:\\n val = 1000\\n self.sensorValues[i] = val\\n\\n print(\\\"calibrated readings\\\")\\n self.print_sensor_values(self.sensorValues)\",\n \"def _calibrate_measurement(self):\\n\\n cold_blackbody = bb_radiance(self.cbb.header.cbb_temperature + 273.15,\\n self.cbb.data.wavelength)\\n warm_blackbody = bb_radiance(self.wbb.header.wbb_temperature + 273.15,\\n self.wbb.data.wavelength)\\n\\n self.wbb.data.average_spectrum[0] = 1\\n self.wbb.data.average_spectrum[2047] = 1\\n\\n calibration_slope = ((warm_blackbody - cold_blackbody) /\\n (self.wbb.data.average_spectrum - self.cbb.data.average_spectrum))\\n calibration_offset = warm_blackbody - (self.wbb.data.average_spectrum * \\n calibration_slope)\\n\\n self.wbb.calibrate_file(calibration_slope, calibration_offset)\\n self.cbb.calibrate_file(calibration_slope, calibration_offset)\\n self.sam.calibrate_file(calibration_slope, calibration_offset)\\n\\n if not self.dwr is None:\\n self.dwr.calibrate_file(calibration_slope, calibration_offset)\\n\\n plate_temperature = self.dwr.header.spare_f[0]\\n if (self.plate == -1) :\\n plate_emissivity = self.dwr.header.spare_f[1]\\n\\n plate_blackbody = bb_radiance(plate_temperature + 273.15,\\n self.dwr.data.wavelength)\\n plate_emission = plate_emissivity * plate_blackbody\\n\\n self.dwr.data.average_spectrum = ((self.dwr.data.average_spectrum - \\n plate_emission) / (1 - plate_emissivity))\",\n \"def folding(eventfile,Porb,nbins):\\n times = fits.open(eventfile)[1].data['TIME'] #getting array of times\\n gtis_data = fits.open(eventfile)[2].data #getting GTIs\\n T = sum([ gtis_data[i]['STOP']-gtis_data[i]['START'] for i in range(len(gtis_data)) ]) #exposure time\\n\\n gtis_conform = []\\n for i in range(len(gtis_data)):\\n gtis_conform.append([gtis_data[i][0],gtis_data[i][1]]) #conform to the input that Stingray uses\\n\\n phase_sr,prof_sr,err_sr = fold_events(times,1/Porb,gtis=np.array(gtis_conform),ref_time=times[0],nbin=nbins)\\n phase_sr_expo,prof_sr_expo,err_sr_expo = fold_events(times,1/Porb,gtis=np.array(gtis_conform),ref_time=times[0],expocorr=True,nbin=nbins)\\n\\n total_phase_sr = list(phase_sr) + list(phase_sr+1)\\n total_prof_sr = list(prof_sr)*2\\n total_err_sr = list(err_sr)*2\\n\\n total_phase_sr_expo = list(phase_sr_expo) + list(phase_sr_expo+1)\\n total_prof_sr_expo = list(prof_sr_expo)*2\\n total_err_sr_expo = list(err_sr_expo)*2\\n\\n plt.figure()\\n plt.errorbar(x=total_phase_sr,y=total_prof_sr/T,yerr=total_err_sr/T,color='r',drawstyle='steps-mid')\\n plt.errorbar(x=total_phase_sr_expo,y=total_prof_sr_expo/T,yerr=total_err_sr_expo/T,color='b',drawstyle='steps-mid')\\n plt.legend(('Folded profile','Exposure-corrected'),loc='best',fontsize=12)\\n plt.title(str(pathlib.Path(eventfile).name) +', exposure-corrected (using Stingray fold_events)',fontsize=12)\\n plt.xlabel('Phase',fontsize=12)\\n plt.ylabel('Counts/s',fontsize=12)\\n\\n return total_phase_sr_expo,total_prof_sr_expo/T,total_err_sr_expo/T\",\n \"def run(self):\\n bridge = CvBridge()\\n rate = rospy.Rate(10)\\n while not rospy.is_shutdown():\\n dist, offset = self.find_position(self.focal_length, self.real_height)\\n\\n print(\\\"EST DISTANCE: \\\" + str(dist) + ' inches')\\n print(\\\"EST OFFSET: \\\" + str(offset) + ' inches')\\n print(\\\"--------------\\\")\\n\\n #heading averaging\\n self.last_point = self.current_point\\n self.current_point = offset[0]\\n new_slope = (self.current_point - self.last_point)\\n if new_slope != 0:\\n new_slope = new_slope / abs(new_slope)\\n if self.current_slope == 1:\\n if new_slope < 0:\\n self.average = self.current_sum / self.count\\n self.current_sum = 0\\n self.count = 0\\n self.current_sum += self.current_point\\n self.count += 1\\n self.current_slope = new_slope\\n\\n #publish the heading and the average heading\\n self.heading_pub.publish(offset[0])\\n self.avg_pub.publish(self.average)\\n\\n #put a red circle on the image where the average heading is\\n if dist != 0:\\n center_x = int(self.average*self.focal_length/dist + self.image_center[0])\\n center_y = int(-1.0*offset[1]*self.focal_length/dist + self.image_center[1])\\n cv_marked_image = cv2.circle(self.image, (center_x, center_y), 15, (0,0,255), 15)\\n marked_image = bridge.cv2_to_imgmsg(cv_marked_image, encoding='bgr8')\\n self.image_pub.publish(marked_image)\\n rate.sleep()\",\n \"def plot_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2014/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\t#labels = ['no APMB', 'APMB']\\n\\t#if labels == '':\\n\\tlabels = steps\\n\\tdeep = {}\\n\\t#uzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\t\\tprint(pointsFile)\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\t'''\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t#normalize\\n\\tuz_fem = uz_fem / uzmax\\n\\tur_fem = ur_fem / uzmax\\n\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\t'''\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def plot_mean_hfo(evlist,color='blue', xlim =[-1,1], figure_size=(10,10),dpi=600,saveplot = None):\\n f = plt.figure(figsize=figure_size,dpi=dpi)\\n \\n \\n \\n \\n raw = np.array([]) # creating a empty array \\n filt = np.array([]) # creating a empty array\\n pxx = np.array([]) # creating a empty array\\n nwave, a = evlist[0].waveform.shape\\n time_v = np.linspace(-1,1,nwave,endpoint=True)\\n npw, = evlist[0].spectrum.nPxx.shape\\n F = evlist[0].spectrum.F\\n for hfo in evlist:\\n raw = np.append(raw, hfo.waveform[:,0])\\n #ax1.plot(time_v,hfo.waveform[:,0],lw=.5)\\n filt = np.append(filt, hfo.waveform[:,1])\\n #ax2.plot(time_v,hfo.waveform[:,1],lw=.5)\\n pxx = np.append(pxx, hfo.spectrum.nPxx)\\n \\n raw = raw.reshape(len(evlist),nwave)\\n filt = filt.reshape(len(evlist),nwave)\\n pxx = pxx.reshape(len(evlist),npw)\\n\\n \\n \\n \\n ax1 = plt.subplot(311)\\n m = np.mean(raw,0)\\n s = np.std(raw,0)/np.sqrt(raw.shape[0])\\n plt.plot(time_v,m,'k',lw=2)\\n #ax1.fill_between(time_v,m+s,m-s, facecolor=color, alpha=0.1)\\n ax1.set_xlim(xlim)\\n adjust_spines(ax1, ['left'])\\n \\n ax2 = plt.subplot(312)\\n m = np.mean(filt,0)\\n s = np.std(filt,0)/np.sqrt(filt.shape[0])\\n plt.plot(time_v,m,'k',lw=2)\\n #ax2.fill_between(time_v,m+s,m-s, facecolor=color, alpha=0.1)\\n ax2.set_xlim(xlim)\\n adjust_spines(ax2, ['left', 'bottom'])\\n \\n ax3 = plt.subplot(313)\\n m = np.mean(pxx,0)\\n s = np.std(pxx,0)/np.sqrt(pxx.shape[0])\\n plt.plot(F,m,'k',lw=2)\\n ax3.fill_between(F,m+s,m-s, facecolor=color, alpha=0.1)\\n adjust_spines(ax3, ['left', 'bottom'])\\n \\n if saveplot != None:\\n if type(saveplot) == str: \\n plt.savefig(saveplot, bbox_inches='tight')\\n else:\\n raise Exception('saveplot should be a string')\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def avg(self):\\n return sum(self.times) / len(self.times)\",\n \"def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:\",\n \"def display(self,anchor_name = ANCHOR_NAME ,mode = '2D'):\\n res = self.read_mes()\\n \\n \\n \\n \\n ref_points = res[0]\\n positions = res[1]\\n \\n \\n \\n # print(ref_points)\\n # print(rangings)\\n out = [] # will be returned\\n measured_positions = [] # measured ranging value for the reference point\\n real_positions = [] # real ranging value for the reference point\\n \\n #abs_standard_deviation = []\\n #relative_standard_deviation = []\\n \\n abs_accuracies = []\\n #relative_accuracies = []\\n \\n #angles = angle(ref_points,anchor_name)\\n \\n for (i,rp) in enumerate(ref_points):\\n serie = positions[i]\\n \\n (real_position,mean_position,mean_accuracy) = self.extract_serie(serie,rp)\\n \\n # getting error for anchor A\\n #print(get_ranging_error('A',mean_position,rp) )\\n measured_positions.append(mean_position)\\n real_positions.append(real_position)\\n abs_accuracies.append(mean_accuracy)\\n \\n global_accuracy = np.mean(abs_accuracies)\\n print(\\\"average accuracy :\\\" + str(global_accuracy) )\\n \\n \\n \\n \\n # displaying averaged values\\n \\n \\n \\n \\n \\n \\n measured_x = []\\n measured_y = []\\n measured_z = []\\n real_x = []\\n real_y = []\\n real_z = []\\n for pos in measured_positions:\\n (x,y,z) = pos\\n measured_x.append(x)\\n measured_y.append(y)\\n measured_z.append(z)\\n \\n for pos in real_positions:\\n (x,y,z) = pos\\n real_x.append(x)\\n real_y.append(y)\\n real_z.append(z)\\n \\n \\n \\n \\n \\n \\n \\n if (mode == '2D'):\\n \\n \\n \\n # plotting results\\n \\n # creating figures \\n fig1 = plt.figure(\\\"Accuracy\\\")\\n fig2 = plt.figure(\\\"Positions\\\") \\n \\n # creating axes \\n ax1 = fig1.add_subplot(111,projection='3d')\\n ax1.view_init(elev = 45, azim = 240)\\n ax1.set_title(\\\"absolute accuracy\\\")\\n ax1.plot(real_x[:],real_y[:],abs_accuracies[:])\\n \\n \\n \\n \\n \\n ax2 = fig2.add_subplot(111)\\n ax2.set_title(\\\"Real positions\\\")\\n ax2.scatter(real_x[:],real_y[:])\\n \\n ax2 = fig2.add_subplot(111)\\n ax2.set_title(\\\"Measured positions\\\")\\n ax2.scatter(measured_x[:],measured_y[:])\\n \\n \\n \\n \\n \\n \\n \\n if (mode == '3D'):\\n # plotting results\\n \\n # creating figures \\n fig1 = plt.figure(\\\"Accuracy\\\")\\n fig2 = plt.figure(\\\"Positions\\\") \\n \\n # creating axes \\n ax1 = fig1.add_subplot(111,projection='3d')\\n ax1.view_init(elev = 45, azim = 240)\\n ax1.set_title(\\\"absolute accuracy\\\")\\n ax1.plot(real_x[:],real_y[:],abs_accuracies[:])\\n \\n \\n \\n \\n \\n ax2 = fig2.add_subplot(111,projection='3d')\\n ax2.view_init(elev = 45, azim = 240)\\n ax2.set_title(\\\"Real positions\\\")\\n ax2.scatter(real_x[:],real_y[:],real_z[:])\\n \\n ax2 = fig2.add_subplot(111,projection='3d')\\n ax2.view_init(elev = 45, azim = 240)\\n ax2.set_title(\\\"Measured positions\\\")\\n ax2.scatter(measured_x[:],measured_y[:],measured_z[:])\\n \\n \\n \\n if (DISPLAY): \\n plt.show()\\n \\n \\n return(out)\",\n \"def update_average_best_fit(self):\\r\\n # print(result_buffer)\\r\\n total = len(self.result_buffer)\\r\\n left_fit, right_fit = np.empty((0, 3)), np.empty((0, 3))\\r\\n left_curve_rad, right_curve_rad = [], []\\r\\n vehicle_offset = []\\r\\n for i in range(total):\\r\\n calc_fit_dict = self.result_buffer[i]\\r\\n left_fit = np.append(left_fit, [calc_fit_dict['left_fit']], axis=0)\\r\\n right_fit = np.append(right_fit, [calc_fit_dict['right_fit']], axis=0)\\r\\n left_curve_rad.append(calc_fit_dict['left_curve_rad'])\\r\\n right_curve_rad.append(calc_fit_dict['right_curve_rad'])\\r\\n vehicle_offset.append(calc_fit_dict['vehicle_offset'])\\r\\n self.avg_fit_dict['left_fit'] = np.mean(left_fit, axis=0)\\r\\n self.avg_fit_dict['right_fit'] = np.mean(right_fit, axis=0)\\r\\n self.avg_fit_dict['left_curve_rad'] = np.mean(left_curve_rad)\\r\\n self.avg_fit_dict['right_curve_rad'] = np.mean(right_curve_rad)\\r\\n self.avg_fit_dict['vehicle_offset'] = np.mean(vehicle_offset)\\r\\n # print(avg_fit_dict)\\r\\n return\",\n \"def plot_averaged_amplitude(self):\\r\\n\\r\\n tremap = np.arange(0, self.period, 1./self.framerate)\\r\\n\\r\\n ipy_offset = -2\\r\\n\\r\\n # find center of image\\r\\n\\r\\n self.ipx = int(self.imageData.shape[1]/2.)\\r\\n\\r\\n self.ipy = int(self.imageData.shape[2]/2.)\\r\\n\\r\\n posx = range(1, self.imageData.shape[1]-1, 2)\\r\\n\\r\\n colormap = mpl.cm.gist_ncar\\r\\n\\r\\n colx = [colormap(i) for i in np.linspace(0, 0.9, (len(posx)))]\\r\\n\\r\\n for i, px in enumerate(posx):\\r\\n\\r\\n remapped1 = self.measure_amplitude(self.ipy+ipy_offset, px)\\r\\n\\r\\n mpl.plot(tremap, remapped1/self.meanimagevalue, 'o-', markerfacecolor=colx[i], markersize=2.0)\\r\\n\\r\\n mpl.title('Averaged Amplitude Center')\\r\\n\\r\\n return (ipy_offset, posx, colx)\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def test4():\\n\\t\\n\\tprint('This takes a while to compute - be patient!')\\n\\t\\n\\td = np.linspace(-15000,15000,300)\\n\\t#Voigt\\n\\t#p_dict = {'Bfield':700,'rb85frac':1,'Btheta':90*np.pi/180,'lcell':75e-3,'T':84,'Dline':'D2','Elem':'Cs'}\\n\\tp_dict = {'Bfield':1000,'rb85frac':1,'Btheta':88*np.pi/180,'Bphi':00*np.pi/180,'lcell':75e-3,'T':93,'Dline':'D2','Elem':'Cs'}\\n\\tpol = np.array([1.0,0.0,0.0])\\n\\tTVx = get_spectra(d,pol,p_dict,outputs=['I_M45','I_P45','Ix','Iy','S0','Iz'])\\n\\t\\n\\tfig2 = plt.figure()\\n\\tax1a = fig2.add_subplot(411)\\n\\tax2a = fig2.add_subplot(412,sharex=ax1a)\\n\\tax3a = fig2.add_subplot(413,sharex=ax1a)\\n\\tax4a = fig2.add_subplot(414,sharex=ax1a)\\n\\t\\n\\tax1a.plot(d,TVx[0],'r',lw=2,label=r'$I_{-45}$')\\n\\tax2a.plot(d,TVx[1],'b',lw=2,label=r'$I_{+45}$')\\n\\tax3a.plot(d,TVx[2],'r',lw=2,label=r'$I_x$')\\n\\tax4a.plot(d,TVx[3],'b',lw=2,label=r'$I_y$')\\n\\tax4a.plot(d,TVx[0]+TVx[1],'r:',lw=3.5,label=r'$I_{+45}+I_{-45}$')\\n\\tax4a.plot(d,TVx[2]+TVx[3],'k:',lw=2.5,label=r'$I_x + I_y$')\\n\\tax4a.plot(d,TVx[4],'g--',lw=1.5,label='$S_0$')\\n#\\tax4a.plot(d,TVx[5],'c--',lw=2.5,label='$I_z$')\\n\\t\\n\\t\\n\\tax4a.set_xlabel('Detuning (MHz)')\\n\\tax1a.set_ylabel('I -45')\\n\\tax2a.set_ylabel('I +45')\\n\\tax3a.set_ylabel('Ix')\\n\\tax4a.set_ylabel('Iy')\\n\\t\\n\\tax4a.set_xlim(d[0],d[-1]+3000)\\n\\tax4a.legend(loc=0)\\n\\t\\n\\tplt.show()\",\n \"def recall_precision_shots(movie_id):\\n \\n scenes = moviegraphs.load_scenes(movie_id, all_mg)\\n # s is the starting second of the movie (after the opneing credits)\\n # e is the ending second of the movie (before the ending credits)\\n s, e = scenes[0][0], scenes[-1][1]\\n with open(json_dir + movie_id + '.json') as f:\\n data = json.load(f)\\n \\n MG = [i for i in moviegraphs.load_cuts(vid_dir, movie_id) if s < i < e]\\n VI = [i for i in videoindexer.load_cuts(data) if s < i < e]\\n \\n count = 0\\n for i in range(len(MG)):\\n if i == 0: prev = 0\\n for j in range(prev, len(VI)):\\n if VI[j] - 1 <= MG[i] <= VI[j] + 1:\\n prev = j + 1\\n count += 1\\n return (round(count / len(VI), 3), round(count / len(MG), 3))\",\n \"def plot_sum(self):\\n fig, ax = plt.subplots()\\n ax.set_title(\\\"Unpolarized intensity: I_up + I_down\\\")\\n ax.set_xlabel(\\\"Time (microseconds)\\\")\\n ax.set_ylabel('Intensity')\\n\\n if (self.is_attribute(\\\"time\\\") & self.is_attribute(\\\"intensity_up\\\") & \\n self.is_attribute(\\\"intensity_up_sigma\\\") &\\n self.is_attribute(\\\"intensity_down\\\") & \\n self.is_attribute(\\\"intensity_down_sigma\\\") &\\n self.is_attribute(\\\"intensity_up_total\\\") &\\n self.is_attribute(\\\"intensity_down_total\\\")):\\n np_excl = numpy.array(self.excluded, dtype=bool)\\n np_notexcl = numpy.logical_not(np_excl)\\n np_time = numpy.array(self.time, dtype=float)\\n np_up = numpy.array(self.intensity_up, dtype=float)\\n np_sup = numpy.array(self.intensity_up_sigma, dtype=float)\\n np_up_mod = numpy.array(self.intensity_up_total, dtype=float)\\n np_down = numpy.array(self.intensity_down, dtype=float)\\n np_sdown = numpy.array(self.intensity_down_sigma, dtype=float)\\n np_down_mod = numpy.array(self.intensity_down_total, dtype=float)\\n np_sum = np_up + np_down\\n np_sum_mod = np_up_mod + np_down_mod\\n np_ssum = numpy.sqrt(numpy.square(np_sup)+numpy.square(np_sdown))\\n ax.plot(np_time, np_sum_mod, \\\"k-\\\", label=\\\"model\\\")\\n ax.errorbar(np_time[np_notexcl], np_sum[np_notexcl], yerr=np_ssum[np_notexcl], fmt=\\\"ko\\\", alpha=0.2, label=\\\"experiment\\\")\\n ax.errorbar(np_time[np_excl], np_sum[np_excl], yerr=np_ssum[np_excl], fmt=\\\"rs\\\", alpha=0.2, label=\\\"excluded\\\")\\n\\n y_min_d, y_max_d = ax.get_ylim()\\n param = y_min_d-(np_sum - np_sum_mod).max()\\n coeff = np_notexcl.astype(int)\\n\\n ax.plot([np_time.min(), np_time.max()], [param, param], \\\"k:\\\")\\n ax.plot(np_time, coeff*(np_sum - np_sum_mod)+param, \\\"r-\\\", alpha=0.7,\\n label=\\\"difference\\\")\\n elif (self.is_attribute(\\\"time\\\") & self.is_attribute(\\\"intensity\\\") & \\n self.is_attribute(\\\"intensity_total\\\") &\\n self.is_attribute(\\\"intensity_sigma\\\")):\\n np_excl = numpy.array(self.excluded, dtype=bool)\\n np_notexcl = numpy.logical_not(np_excl)\\n np_time = numpy.array(self.time, dtype=float)\\n np_sum = numpy.array(self.intensity, dtype=float)\\n np_sum_mod = numpy.array(self.intensity_total, dtype=float)\\n np_ssum = numpy.array(self.intensity_sigma, dtype=float)\\n ax.plot(np_time, np_sum_mod, \\\"k-\\\", label=\\\"model\\\")\\n ax.errorbar(np_time[np_notexcl], np_sum[np_notexcl], yerr=np_ssum[np_notexcl], fmt=\\\"ko\\\", alpha=0.2, label=\\\"experiment\\\")\\n ax.errorbar(np_time[np_excl], np_sum[np_excl], yerr=np_ssum[np_excl], fmt=\\\"rs\\\", alpha=0.2, label=\\\"excluded\\\")\\n\\n y_min_d, y_max_d = ax.get_ylim()\\n param = y_min_d-(np_sum - np_sum_mod).max()\\n coeff = np_notexcl.astype(int)\\n\\n ax.plot([np_time.min(), np_time.max()], [param, param], \\\"k:\\\")\\n ax.plot(np_time, coeff*(np_sum - np_sum_mod)+param, \\\"r-\\\", alpha=0.7,\\n label=\\\"difference\\\")\\n ax.legend(loc='upper right')\\n fig.tight_layout()\\n return (fig, ax)\",\n \"def plot_overscan_variation(t_lst, overscan_lst, figfile):\\n \\n # Quality check plot of the mean overscan value over time \\n fig = plt.figure(figsize=(8,6), dpi=150)\\n ax2 = fig.add_axes([0.1,0.60,0.85,0.35])\\n ax1 = fig.add_axes([0.1,0.15,0.85,0.35])\\n #conversion of the DATE-string to a number\\n date_lst = [dateutil.parser.parse(t) for t in t_lst]\\n datenums = mdates.date2num(date_lst)\\n\\n ax1.plot_date(datenums, overscan_lst, 'r-', label='mean')\\n ax2.plot(overscan_lst, 'r-', label='mean')\\n for ax in fig.get_axes():\\n leg = ax.legend(loc='upper right')\\n leg.get_frame().set_alpha(0.1)\\n ax1.set_xlabel('Time')\\n ax2.set_xlabel('Frame')\\n ax1.set_ylabel('Overscan mean ADU')\\n ax2.set_ylabel('Overscan mean ADU')\\n # adjust x and y limit\\n y11,y12 = ax1.get_ylim()\\n y21,y22 = ax2.get_ylim()\\n z1 = min(y11,y21)\\n z2 = max(y21,y22)\\n ax1.set_ylim(z1,z2)\\n ax2.set_ylim(z1,z2)\\n ax2.set_xlim(0, len(overscan_lst)-1)\\n # adjust rotation angle of ticks in time axis\\n plt.setp(ax1.get_xticklabels(),rotation=30)\\n\\n # save figure\\n fig.savefig(figfile)\\n plt.close(fig)\",\n \"def coldaverage( names):\\n\\n rs = radioastronomy.Spectrum() # create input and average structures\\n avenames = names # create an output list to average\\n\\n# assume only a limited range of galactic latitudes are available\\n# not range above +/-60.\\n use60Range = False\\n minGlat = 90. # initialize to extremea\\n maxGlat = -90.\\n maxEl = -90.\\n minEl = 90.\\n ncold = 0\\n\\n # for all input files\\n for filename in names:\\n\\n parts = filename.split('/')\\n nparts = len(parts)\\n if nparts == 1:\\n aname = parts[0]\\n else:\\n aname = parts[nparts-1]\\n\\n parts = aname.split('.')\\n nparts = len(parts)\\n if nparts < 2:\\n print 'File is not an astronomy file: ',filename\\n continue\\n else:\\n extension = parts[nparts-1]\\n\\n extension = extension.upper()\\n if extension != 'AST': # speed up by only looking at astronomy files\\n continue\\n \\n rs.read_spec_ast(filename) # An observation, read values\\n\\n if rs.telel < 0: # only working with observations, skip elevation <= 0.\\n continue\\n\\n maxGlat = max( rs.gallat, maxGlat)\\n minGlat = min( rs.gallat, minGlat)\\n maxEl = max( rs.telel, maxEl)\\n minEl = min( rs.telel, minEl)\\n # end for all files loop, looking for max el and latitude ranges\\n\\n # if any high galactic latitudes, use only above +/-60d \\n if minGlat < -60. or maxGlat > 60.:\\n minGlat = -60.\\n maxGlat = 60.\\n else: # else no high galactic latitude data\\n # use highest galactic latitudes - +/-5.degrees\\n if -minGlat > maxGlat: # if negative latitudes higher\\n minGlat = minGlat + 5.\\n maxGlat = 90.\\n else: # else positive latitudes higher\\n maxGlat = maxGlat - 5.\\n minGlat = -90.\\n\\n # only use the elevations above 60 degrees, if any\\n if maxEl > 60.:\\n maxEl = 60.\\n else:\\n maxEl = maxEl - 10. #else must use highest elevations available\\n\\n # now average coldest data for calibration\\n for filename in names:\\n\\n rs.read_spec_ast(filename)\\n rs.azel2radec() # compute ra,dec from az,el\\n\\n if rs.telel < maxEl:\\n continue\\n\\n if rs.gallat > maxGlat or rs.gallat < minGlat:\\n avenames[ncold] = filename\\n ncold = ncold + 1\\n # end of for all files loop\\n\\n ncold, cold = average( avenames[0:ncold]) # now use generic program for averages\\n if ncold < 1:\\n print 'No Cold load files; can not calibrate!'\\n exit()\\n\\n return ncold, cold, minEl, maxEl\",\n \"def calibrate(self, eventlog, calibrate=True, validate=False):\\n\\n\\n # # # #calculate thresholds (degrees to pixels)\\n self.pxfixtresh = self._deg2pix(self.screendist, self.fixtresh, self.pixpercm)\\n # in pixels per millisecons\\n self.pxspdtresh = self._deg2pix(self.screendist, self.spdtresh / 1000.0, self.pixpercm)\\n # in pixels per millisecond**2\\n self.pxacctresh = self._deg2pix(self.screendist, self.accthresh / 1000.0, self.pixpercm)\\n\\n # calibration image file\\n calibImg = c.CALIBIMG\\n\\n # initialize a sound\\n snd = sound.Sound(value=c.CALIBSOUNDFILE)\\n snd.setVolume(0.5)\\n\\n # image scaling range\\n bit = 0.02\\n scaleRange = ([x / 100.0 for x in range(60, 30, -2)] + [x / 100.0 for x in range(30, 60, 2)])\\n\\n if calibrate:\\n\\n if not self.eyetracker:\\n print(\\\"WARNING! libtobii.TobiiProTracker.calibrate: no eye trackers found for the calibration!\\\")\\n self.stop_recording()\\n return False\\n\\n calibration = tr.ScreenBasedCalibration(self.eyetracker)\\n\\n calibrating = True\\n calibration.enter_calibration_mode()\\n\\n while calibrating:\\n\\n eventlog.write([\\\"Calibration started at \\\", clock.get_time()])\\n print \\\"----------> Starting calibration...\\\"\\n\\n # original (normalised) points_to_calibrate = [(0.5, 0.5), (0.9, 0.1), (0.1, 0.1), (0.9, 0.9), (0.1, 0.9)]\\n # pixel values are calculated based on the normalised points. With (1920,1200):\\n # self.points_to_calibrate calculated values: [(960, 600), (192, 1080), (192, 120), (1728, 1080), (1728, 120)]\\n\\n # calibration for all calibration points\\n for i in range(0,len(self.points_to_calibrate)):\\n\\n point = self.points_to_calibrate[i]\\n\\n eventlog.write([\\\"\\\\nCalibrating point {0} at: \\\".format(point), clock.get_time()])\\n print \\\"----------> Calibrating at point \\\", point\\n\\n # play the soundfile\\n snd.play()\\n\\n # Shrink from big size to small\\n scale = 1\\n for frameN in range(20): # 20 frames -> 1/3 sec shrinking (180 to 108)\\n\\n self.c_screen.clear()\\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\\n drawCoreImage(self.c_screen, point, i)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n scale = scale - bit\\n\\n # shrink and grow while 'space' is pressed\\n s = 0\\n for frameN in range(12000): # 108 -> 54, 15 frames (1/4 s) and backwards\\n\\n s = frameN%30\\n scale = scaleRange[s]\\n self.c_screen.clear()\\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\\n drawCoreImage(self.c_screen, point, i)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n if self.kb.get_key(keylist=['space'],timeout=10, flush=False)[0] == 'space':\\n break\\n\\n # collect results for point\\n normalized_point = self._px_2_norm(point)\\n collect_result = calibration.collect_data(normalized_point[0], normalized_point[1])\\n print(\\\"----------> Collecting results for point \\\", point)\\n eventlog.write([\\\"Collecting result for point {0} at: \\\".format(point), clock.get_time()])\\n\\n if collect_result != tr.CALIBRATION_STATUS_SUCCESS:\\n eventlog.write([\\\"Recollecting result for point {0} at: \\\".format(point), clock.get_time()])\\n # Try again if it didn't go well the first time.\\n # Not all eye tracker models will fail at this point, but instead fail on ComputeAndApply.\\n calibration.collect_data(normalized_point[0], normalized_point[1])\\n\\n # Shrink back to big size\\n scaleUp = [x / 100.0 for x in range(int(scale*100), 100, 2)]\\n for scale in scaleUp:\\n self.c_screen.clear()\\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\\n drawCoreImage(self.c_screen, point, i)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n\\n # image rolling to next point\\n # pixelised self.points_to_calibrate = [(960, 600), (192, 1080), (192, 120), (1728, 1080), (1728, 120)]\\n if (i < len(self.points_to_calibrate)-1):\\n\\n \\\"\\\"\\\"\\n screen ratio: 16/10\\n The steps for moving the images should be 16, 10 or 8, 5\\n \\\"\\\"\\\"\\n # center -> bottom left / (960, 600) -> (192, 1080) - 48 frames\\n while point[0] >= self.points_to_calibrate[i+1][0]:\\n self.c_screen.clear()\\n point = (point[0]-16, point[1]+10)\\n self.c_screen.draw_image(calibImg, pos=point)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n # bottom-left -> top-left / (192, 1080) -> (192, 120)\\n # AND\\n # bottom-right -> top-right / (1728, 1080) -> (1728, 120) - 80 frames\\n while point[1] > self.points_to_calibrate[i+1][1]:\\n self.c_screen.clear()\\n point = (point[0], point[1]-12)\\n self.c_screen.draw_image(calibImg, pos=point)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n # top-left -> bottom-right / (192, 120) -> (1728, 1080) - 96 frames\\n while point[0] < self.points_to_calibrate[i+1][0] and not point[1] == self.points_to_calibrate[i+1][1]:\\n self.c_screen.clear()\\n point = (point[0]+16, point[1]+10)\\n self.c_screen.draw_image(calibImg, pos=point)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n\\n print(\\\"------------> Calculating calibration result....\\\")\\n\\n calibration_result = calibration.compute_and_apply()\\n\\n eventlog.write([\\\"\\\\nCompute and apply returned {0} and collected at {1} points.\\\\n\\\".\\n format(calibration_result.status, len(calibration_result.calibration_points))])\\n print(\\\"------------> Compute and apply returned {0} and collected at {1} points.\\\".\\n format(calibration_result.status, len(calibration_result.calibration_points)))\\n\\n\\n\\n # Show image after calibration\\n self.c_screen.clear()\\n self.c_screen.draw_image(c.ATT_IMG)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n if calibration_result.status != tr.CALIBRATION_STATUS_SUCCESS:\\n eventlog.write([\\\"\\\\n\\\\nWARNING! libtobii.TobiiProTracker.calibrate: Calibration was unsuccessful!\\\\n\\\\n\\\"])\\n print \\\"Calibration was unsuccessful.\\\\nPress 'R' to recalibrate all points\\\\nor 'SPACE' to continue without calibration\\\"\\n key = self.kb.get_key(keylist=['space', 'r'], timeout=None)[0]\\n if key == 'r':\\n recalibration_points = [0]\\n elif key == 'space':\\n recalibration_points = []\\n\\n else:\\n # call showCalibrationResults function to present the results on screen 0. The function returns a list\\n logfiledir = os.path.dirname(os.path.abspath(self.datafilepath))\\n recalibration_points = showCalibrationResults(logfiledir, calibration_result)\\n\\n # if the list is empty, calibration is finished\\n if len(recalibration_points) == 0:\\n eventlog.write([\\\"\\\\nCalibration finished at \\\", clock.get_time()])\\n calibrating = False\\n\\n # if the list contains only '0', the calibration was unsuccessful, recalibrate all points\\n elif (recalibration_points[0] == 0):\\n eventlog.write([\\\"\\\\nRecalibrating all points...\\\"])\\n calibrating = True\\n # if the list contains only '1', recalibrate all points despite successful calibration\\n elif (recalibration_points[0] == 1):\\n eventlog.write([\\\"\\\\nRecalibrating all points...\\\"])\\n for point in self.points_to_calibrate:\\n calibration.discard_data(point[0], point[1])\\n calibrating = True\\n # recalibrate the returned points\\n else:\\n eventlog.write([\\\"\\\\nRecalibrating {0} points...\\\".format(len(recalibration_points))])\\n self.points_to_calibrate = [self._norm_2_px(p) for p in recalibration_points]\\n for point in self.points_to_calibrate:\\n calibration.discard_data(point[0], point[1])\\n calibrating = True\\n\\n\\n calibration.leave_calibration_mode()\\n eventlog.write([\\\" Leaving calibration mode...\\\", clock.get_time()])\\n self.stop_recording()\\n self._write_enabled = True\\n self.disp.close()\",\n \"def find_change_points_fill(self):\\r\\n # Fill data with moving window of mean heading and circular stdev\\r\\n # - get filled data at 5 second interval\\r\\n # - calculate headings of filled data\\r\\n # - calculate mean and circular stdev in moving window. \\r\\n # - look for points where forward window mean differs from backward\\r\\n # window mean by more than 2 stdev\\r\\n rec_fill = self.rec_smooth_fill\\r\\n segs = self.make_segments(set_depth=True, input_rec_track=rec_fill,\\r\\n overwrite_rec_seg=False)\\r\\n # need rec_track to get valid data points for t-statistic calculation\\r\\n rec_raw = self.rec_track\\r\\n not_flagged = np.where(rec_raw.flagged==0)[0]\\r\\n rec_raw_valid = rec_raw[not_flagged]\\r\\n nfill = len(rec_fill)\\r\\n nseg = nfill - 1\\r\\n window = 12\\r\\n cvar, cavg = self.circular_std_dev(window=int(window/2), headings=segs.head)\\r\\n change_pt = np.zeros(nfill, np.bool_)\\r\\n change_pt0 = np.zeros(nfill, np.bool_)\\r\\n p_stat = np.ones(nfill, np.float64)\\r\\n small_cstd = 0.1*np.pi\\r\\n for nf in range(int(window/2+1),int(nfill-window/2-1)):\\r\\n nf_before = int(nf - window/4)\\r\\n nf_after = int(nf + window/4)\\r\\n cb = cavg[nf_before]\\r\\n ca = cavg[nf_after]\\r\\n #dy = np.sin(cb - ca)\\r\\n #dx = np.cos(cb - ca)\\r\\n #del_avg = math.atan2(dy, dx)\\r\\n del_avg = (cb-ca+np.pi)%(2.0*np.pi)-np.pi\\r\\n #avg_var = np.average([cvar[nf_before], cvar[nf_after]])\\r\\n #cstd = max(np.sqrt(avg_var),small_cstd)\\r\\n t1 = segs.t1[nf_before]\\r\\n t2 = segs.t2[nf_after]\\r\\n tf = rec_fill.Sec[nf]\\r\\n td = rec_raw_valid.Sec\\r\\n # calculate sample size\\r\\n n1 = max(1, np.sum(np.logical_and(td >= t1, td <= tf)))\\r\\n n2 = max(1, np.sum(np.logical_and(td <= t2, td >= tf)))\\r\\n #idet = np.where((td >= t1) & (td <= t2))[0]\\r\\n #nd = len(idet) # number of original detections in window\\r\\n # http://www.stat.yale.edu/Courses/1997-98/101/meancomp.htm\\r\\n # degrees of freedom is min(n1,n2)-1\\r\\n #df = 2*nd - 2\\r\\n #df = max(1, df)\\r\\n #t_stat = del_avg/(cstd*np.sqrt(df))\\r\\n #avg_var = np.average([cvar[nf_before], cvar[nf_after]])\\r\\n denominator = np.sqrt(cvar[nf_before]/n1 + cvar[nf_after]/n2)\\r\\n denominator = max(0.05*np.pi, denominator)\\r\\n t_stat = abs(del_avg)/denominator\\r\\n df = max(1, min(n1, n2)-1)\\r\\n p_stat[nf] = 1 - stats.t.cdf(t_stat, df=df)\\r\\n #print self.ID, nd, df, del_avg, cstd, t_stat, p_stat[nf]\\r\\n #change_pt[nf] = abs(del_avg) > 3.*avg_std\\r\\n change_pt0[nf] = p_stat[nf] < 0.05\\r\\n for nf in range(int(window/2+1),int(nfill-window/2-1)):\\r\\n # flag current point only if it is the smallest p_stat in window\\r\\n if change_pt0[nf]:\\r\\n nf_before = nf - int(window/4)\\r\\n nf_after = nf + int(window/4)\\r\\n nf_min = np.argmin(p_stat[nf_before:nf_after])\\r\\n if nf == nf_min + nf_before:\\r\\n change_pt[nf] = True\\r\\n\\r\\n self.df_smooth_fill = self.df_smooth_fill.assign(change_pt=change_pt)\\r\\n self.df_smooth_fill = self.df_smooth_fill.assign(p_stat=p_stat)\\r\\n self.rec_smooth_fill = self.df_smooth_fill.to_records()\\r\\n\\r\\n return\",\n \"def measure(mode, x, y, x0, x1, thresh = 0):\\n xt = x.view(numpy.ndarray) # strip Metaarray stuff -much faster!\\n v = y.view(numpy.ndarray)\\n \\n xm = ma.masked_outside(xt, x0, x1).T\\n ym = ma.array(v, mask = ma.getmask(xm))\\n if mode == 'mean':\\n r1 = ma.mean(ym)\\n r2 = ma.std(ym)\\n if mode == 'max' or mode == 'maximum':\\n r1 = ma.max(ym)\\n r2 = xm[ma.argmax(ym)]\\n if mode == 'min' or mode == 'minimum':\\n r1 = ma.min(ym)\\n r2 = xm[ma.argmin(ym)]\\n if mode == 'median':\\n r1 = ma.median(ym)\\n r2 = 0\\n if mode == 'p2p': # peak to peak\\n r1 = ma.ptp(ym)\\n r2 = 0\\n if mode == 'std': # standard deviation\\n r1 = ma.std(ym)\\n r2 = 0\\n if mode == 'var': # variance\\n r1 = ma.var(ym)\\n r2 = 0\\n if mode == 'cumsum': # cumulative sum\\n r1 = ma.cumsum(ym) # Note: returns an array\\n r2 = 0\\n if mode == 'anom': # anomalies = difference from averge\\n r1 = ma.anom(ym) # returns an array\\n r2 = 0\\n if mode == 'sum':\\n r1 = ma.sum(ym)\\n r2 = 0\\n if mode == 'area' or mode == 'charge':\\n r1 = ma.sum(ym)/(ma.max(xm)-ma.min(xm))\\n r2 = 0\\n if mode == 'latency': # return first point that is > threshold\\n sm = ma.nonzero(ym > thresh)\\n r1 = -1 # use this to indicate no event detected\\n r2 = 0\\n if ma.count(sm) > 0:\\n r1 = sm[0][0]\\n r2 = len(sm[0])\\n if mode == 'count':\\n r1 = ma.count(ym)\\n r2 = 0\\n if mode == 'maxslope':\\n return(0,0)\\n slope = numpy.array([])\\n win = ma.flatnotmasked_contiguous(ym)\\n st = int(len(win)/20) # look over small ranges\\n for k in win: # move through the slope measurementwindow\\n tb = range(k-st, k+st) # get tb array\\n newa = numpy.array(self.dat[i][j, thisaxis, tb])\\n ppars = numpy.polyfit(x[tb], ym[tb], 1) # do a linear fit - smooths the slope measures\\n slope = numpy.append(slope, ppars[0]) # keep track of max slope\\n r1 = numpy.amax(slope)\\n r2 = numpy.argmax(slope)\\n return(r1, r2)\",\n \"def eeg_det_ptp_avg(array,win_p1,win_n1,win_p2,tim):\\t\\n\\tnsub,npts = array.shape\\n\\tidx_p1 = np.squeeze(np.logical_and(tim>=win_p1[0],tim<=win_p1[1]))\\n\\tidx_n1 = np.squeeze(np.logical_and(tim>=win_n1[0],tim<=win_n1[1]))\\n\\tidx_p2 = np.squeeze(np.logical_and(tim>=win_p2[0],tim<=win_p2[1]))\\n\\t\\n\\tptp_val = np.zeros(nsub)\\n\\tfor i in range(nsub):\\t\\n\\t\\tp1 = np.mean(array[i,idx_p1],axis=0)\\n\\t\\tn1 = np.mean(array[i,idx_n1],axis=0)\\t\\n\\t\\tp2 = np.mean(array[i,idx_p2],axis=0)\\n\\t\\tptp_val[i] = (p1+p2)/2 - n1\\n\\t\\t\\n\\treturn ptp_val\",\n \"def track_quality_metrics(self, masked=False):\\r\\n grd = self.grd\\r\\n if masked:\\r\\n not_flagged = np.where(self.rec_track.flagged==0)[0]\\r\\n tr = self.rec_track[not_flagged]\\r\\n # smooth track\\r\\n #trs = self.rec_smooth_pos[not_flagged]\\r\\n # assume that smoothed position is already masked\\r\\n trs = self.rec_smooth_pos\\r\\n seg = self.make_segments(set_depth=True, input_rec_track=tr)\\r\\n mask = not_flagged\\r\\n else:\\r\\n tr = self.rec_track\\r\\n trs = self.rec_smooth_pos\\r\\n seg = self.rec_seg\\r\\n mask = None\\r\\n detects = len(tr.X)\\r\\n possible_detects = (tr.Sec[-1] - tr.Sec[0])/dt_signal\\r\\n non_detects = possible_detects - detects\\r\\n frac_detects = float(detects)/float(possible_detects)\\r\\n max_depth = np.max(tr.depth)\\r\\n z_over_H = np.minimum(1.,np.divide(tr.Z,np.maximum(depth_min,tr.depth)))\\r\\n ivalid = np.where(np.isfinite(z_over_H))[0]\\r\\n avg_ht = np.average(1.0 - z_over_H[ivalid])\\r\\n avg_z = np.average(tr.Z)\\r\\n valid_depth = np.where(np.isfinite(tr.depth))[0]\\r\\n avg_depth = np.average(tr.depth[valid_depth])\\r\\n velocity_sd = np.std(seg.speed)\\r\\n dv = self.del_velocity(input_rec_track=trs)\\r\\n del_velocity_mag = np.average(np.abs(dv))\\r\\n del_velocity_sd = np.std(np.abs(dv))\\r\\n max_speed = np.max(np.absolute(seg.speed))\\r\\n detects_outside_grid = self.detects_outside_grid()\\r\\n t_elapsed = tr.Sec[-1] - tr.Sec[0]\\r\\n ivalid = np.where(np.isfinite(trs.noise))[0]\\r\\n pos_error = np.average(trs.noise[ivalid])\\r\\n t_entry = tr.dnums[0]\\r\\n hour = (t_entry - math.trunc(t_entry))*24.\\r\\n if (hour > 7) and (hour < 19):\\r\\n daytime_entry = True\\r\\n else:\\r\\n daytime_entry = False\\r\\n mnames = ['ID', 'ndetects','non_detects', 'frac_detects', 'max_depth', \\r\\n 'avg_depth', 'avg_ht', 'avg_z', 'vel_sd', \\r\\n 'dvel_mag', 'dvel_sd', 'invalid_cell', 'pos_error', \\r\\n 't_elapsed','daytime_entry']\\r\\n metrics = [self.ID, detects, non_detects, frac_detects, max_depth, \\r\\n avg_depth, avg_ht, avg_z, velocity_sd, del_velocity_mag, \\r\\n del_velocity_sd, detects_outside_grid, pos_error, \\r\\n t_elapsed, daytime_entry]\\r\\n self.mnames = mnames\\r\\n self.metrics = metrics\\r\\n\\r\\n return mnames, metrics\\r\\n #print self.ID, non_detects, frac_detects, min_depth, velocity_sd, \\\\\\r\\n # detects_outside_grid\\r\",\n \"def EPI():\\n TE = np.array([4.22, 33.81, 63.39, 92.98, 122.6, 152.2, 181.7, 211.3, 240.9, 270.5])\\n upper_left = np.array([697.3, 367.0, 217.5, 115.8, 51.8, 23.2, 14.8, 8.7, 6.1, 4.6])\\n center = np.array([1110.2, 907.8, 813.6, 745.2, 692.8, 637.0, 564.9, 521.0, 450.2, 401.6])\\n lower_right = np.array([723.0, 419.2, 224.1, 126.4, 61.8, 32.4, 15.1, 8.8, 3.9, 3.8])\\n upper_center = np.array([782.2, 499.4, 279.5, 154.5, 88.6, 58.2, 43.8, 38.2, 38.2, 36.0])\\n\\n area = [upper_left, center, upper_center, lower_right]\\n colors = [\\\"#1f77b4\\\", \\\"#ff7f0e\\\", \\\"#2ca02c\\\", \\\"#d62728\\\"]\\n name = [\\\"Upper left area\\\", \\\"Center area\\\", \\\"Up center area\\\", \\\"Lower right area\\\"]\\n x_new = np.linspace(4.22, 270.5, 10000)\\n for i, j, k in zip(area, colors, name):\\n popt, _ = curve_fit(M_xy, TE, i, p0=np.array([200, 300]))\\n M0, T2 = popt[0], popt[1]\\n y_new = M_xy(x_new, M0, T2)\\n plt.scatter(TE, i)\\n plt.plot(x_new, y_new, \\\"--\\\", c=j, label=\\\"Fit: %s\\\" % k + f\\\", $T_2$={T2:.2f}\\\")\\n plt.legend(loc=\\\"best\\\")\\n plt.grid()\\n plt.ylabel(\\\"Mean Signal Intensity\\\")\\n plt.xlabel(\\\"TE [ms]\\\")\\n plt.show()\",\n \"def performancePlot(plot=\\\"ROC\\\"):\\n fig, ax = plt.subplots()\\n colors = {\\\"ML\\\": \\\"red\\\", \\\"Null YFP\\\": \\\"gold\\\", \\\"Null DAPI\\\": \\\"blue\\\"}\\n mapp = pickle.load(open(\\\"pickles/mapp_fold_-1.pk\\\", \\\"rb\\\"))\\n null_mapp = pickle.load(open(\\\"pickles/null_YFP_mapp_fold_-1.pk\\\", \\\"rb\\\"))\\n null_DAPI_mapp = pickle.load(open(\\\"pickles/null_DAPI_mapp_fold_-1.pk\\\", \\\"rb\\\"))\\n \\n i = 0\\n for m in [mapp, null_mapp, null_DAPI_mapp]:\\n coordinates = [] #list of tuples (thresh, x point, y point) to plot\\n for key in m: ##for each threshold\\n TPs = sum([x[0] for x in m[key]])\\n FPs = sum([x[1] for x in m[key]])\\n TNs = sum([x[2] for x in m[key]])\\n FNs = sum([x[3] for x in m[key]])\\n if plot == \\\"PRC\\\":\\n x = TPs / float(TPs + FNs) #recall (TPR)\\n y = TPs / float(TPs + FPs) #precision\\n if plot == \\\"ROC\\\":\\n x = FPs / float(FPs + TNs) #FPR \\n y = TPs / float(TPs + FNs) #recall (TPR)\\n if not (np.isnan(x) or np.isnan(y)): \\n coordinates.append((key, x, y))\\n coordinates = sorted(coordinates, key=lambda x: x[0]) ##sort by threshold\\n x = [t[1] for t in coordinates][::-1]\\n y = [t[2] for t in coordinates][::-1]\\n # print(i, coordinates)\\n # thresholds = [entry[0] for entry in coordinates]\\n # for j, txt in enumerate(thresholds):\\n # ax.annotate(txt, (x[j], y[j]), fontsize=5)\\n auc = np.trapz(y,x)\\n if i == 0:\\n label = \\\"ML\\\"\\n if i == 1:\\n label = \\\"Null YFP\\\"\\n if i == 2:\\n label = \\\"Null DAPI\\\" \\n ax.plot(x, y, linewidth=2.0, color=colors[label], label=\\\"{} Model, AUC = {}\\\".format(label, str(round(auc, 2)))) \\n i += 1\\n plt.title(\\\"{} Curves\\\".format(plot), fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_xlim((0,1))\\n ax.set_ylim((0,1))\\n plt.rc('font',family='Times New Roman')\\n plt.xticks(fontname=\\\"Times New Roman\\\", fontsize=12)\\n plt.yticks(fontname=\\\"Times New Roman\\\", fontsize=12)\\n if plot == \\\"ROC\\\":\\n ax.set_xlabel(\\\"False Positive Rate\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_ylabel(\\\"True Positive Rate\\\",fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.plot([0, .5, 1], [0,.5, 1], linestyle=\\\"--\\\", linewidth=1.0, color=\\\"black\\\")\\n ax.legend(loc='lower right',prop={\\\"family\\\":\\\"Times New Roman\\\", \\\"size\\\":10})\\n plt.savefig(\\\"matplotlib_figures/ROC.png\\\", dpi=300)\\n if plot == \\\"PRC\\\":\\n positives = TPs + FNs ##doesn't matter which map we use, positive prevalence independent of map \\n total = TPs + FPs + TNs + FNs \\n positive_prevalence = positives / float(total)\\n ax.hlines(y=positive_prevalence, xmin=0, xmax=1, linestyle=\\\"--\\\", linewidth=1.0, color=\\\"black\\\")\\n ax.set_xlabel(\\\"Recall\\\", fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_ylabel(\\\"Precision\\\",fontname=\\\"Times New Roman\\\", fontsize=12)\\n ax.set_xlim((0,1))\\n ax.set_ylim((0,1))\\n ax.legend(loc='upper right',prop={\\\"family\\\":\\\"Times New Roman\\\", \\\"size\\\":10})\\n plt.savefig(\\\"matplotlib_figures/PRC.png\\\", dpi=300)\",\n \"def calculate_average_angles(tube_steps,angular_file,pixel_step,tube_sep,extra_dummy=[]):\\n no_of_overlaps = int(round((len(tube_steps)+len(extra_dummy))/pixel_step))-1\\n correction_array = Array(read_horizontal_corrections(angular_file))\\n no_of_tubes = len(correction_array)\\n counter = array.zeros(no_of_tubes+no_of_overlaps,int)\\n final_values = array.zeros(no_of_tubes+no_of_overlaps,float)\\n for stepno in range(no_of_overlaps+1):\\n counter[stepno:stepno+no_of_tubes]+=array.ones(no_of_tubes,int)\\n final_values[stepno:stepno+no_of_tubes]+=correction_array\\n ave_angles = final_values/counter\\n print 'Check: average angles ' + `ave_angles`\\n print 'Check: counter' + `counter`\\n print 'Check: no of overlaps, tubes: %d %d ' % (no_of_overlaps,no_of_tubes)\\n # Now apply these average corrections to the actual angles\\n real_step = pixel_step\\n if len(tube_steps)<pixel_step:\\n real_step = len(tube_steps) #for when we have no overlap and missing steps\\n final_values = array.zeros((no_of_tubes+no_of_overlaps)*real_step)\\n print 'Final values has len %d' % len(final_values)\\n for stepno in range(no_of_tubes+no_of_overlaps):\\n final_values[stepno*real_step:(stepno+1)*real_step] = tube_steps + tube_sep*stepno + ave_angles[stepno]\\n return final_values\",\n \"def analysis(avg, yellow, var, edges, texture): \\n r = [a[0] for a in avg]\\n ravg = numpy.mean(r)\\n rmin = min(r) \\n rmax = max(r)\\n g = [a[1] for a in avg]\\n gavg = numpy.mean(g)\\n gmin = min(g) \\n gmax = max(g)\\n b = [a[2] for a in avg]\\n bavg = numpy.mean(b)\\n bmin = min(b) \\n bmax = max(b)\\n \\n \\n print('Red Statistics') \\n print('Average is ', ravg) \\n print('Min is ', rmin)\\n print('Max is ', rmax)\\n \\n print('Green Statistics') \\n print('Average is ', gavg) \\n print('Min is ', gmin)\\n print('Max is ', gmax)\\n \\n print('Blue Statistics') \\n print('Average is ', bavg) \\n print('Min is ', bmin)\\n print('Max is ', bmax)\\n \\n \\n yavg = numpy.mean(yellow)\\n ymin = min(yellow)\\n ymax = max(yellow)\\n \\n print 'Yellow Statistics' \\n print 'Average is ', yavg \\n print 'Min is ', ymin \\n print 'Max is ', ymax\\n \\n vavg = numpy.mean(var)\\n vmin= min(var)\\n vmax = max(var) \\n \\n print 'Color Variance Statistics' \\n print 'Average is ', vavg \\n print 'Min is ', vmin \\n print 'Max is ', vmax\\n \\n eavg = numpy.mean(edges)\\n emin= min(edges)\\n emax = max(edges) \\n \\n print 'Edge Count Statistics' \\n print 'Average is ', eavg \\n print 'Min is ', emin \\n print 'Max is ', emax\\n \\n tavg = numpy.mean(texture) \\n tmin= min(texture)\\n tmax = max(texture) \\n print 'Texture Statistics' \\n print 'Average is ', tavg \\n print 'Min is ', tmin \\n print 'Max is ', tmax\",\n \"def atmgaincal(self,flim=[10000,10500]):\\n sind=self.getscanind()\\n ind=self.expandcal()\\n amm=np.tile(self.am,(self.nf,1)).T\\n x=(self.spec-self.b[ind])/self.g[ind];x=x[sind]\\n x=x/amm[sind]\\n y=x[ np.where((self.za[sind]>=25) & (self.za[sind]<=35))[0] ]\\n \\n #for k in range(y.shape[0]):\\n # y[k]=y[k]-np.nanmedian(y[k])\\n\\n f=self.f+9500\\n find=np.where((f>=flim[0]) & (f<=flim[1]))[0]\\n \\n for k in range(y.shape[0]):\\n x=self.f[find];\\n yy=y[k,find];\\n p=np.polyfit(x,yy,deg=1);\\n y[k]=y[k]-np.poly1d(p)(self.f)\\n\\n return y\",\n \"def perform_event_analysis():\\n\\n tol = 2.0 # Arcmin\\n calib_on_colours = False\\n\\n params = get_args()\\n\\n log = start_log(params)\\n\\n (star_catalog,image_trios,catalog_header) = read_combined_star_catalog(params,log)\\n\\n lightcurves = read_lightcurves(params,log)\\n\\n target = find_target_data(params,star_catalog,lightcurves,image_trios,log)\\n\\n (source, blend) = calc_source_blend_params(params,log)\\n\\n source = calc_source_lightcurve(source, target, log)\\n\\n measure_photometric_source_colours(params,target,log)\\n\\n (det_idx, cat_idx, close_cat_idx) = index_valid_star_entries(star_catalog,\\n target,tol,log,\\n valid_cat=True)\\n\\n deltas = calibrate_instrumental_colour_colour_diagram(params,star_catalog,\\n catalog_header,target,\\n det_idx,cat_idx,close_cat_idx,\\n log,\\n calib=calib_on_colours)\\n\\n RC = localize_red_clump(star_catalog,close_cat_idx,log)\\n\\n analyse_colour_mag_diagrams(params,star_catalog,catalog_header,\\n target, source,blend,RC,\\n det_idx,cat_idx,close_cat_idx,log)\\n\\n RC = measure_RC_offset(params,RC,target,log)\\n\\n (target,source,blend) = calc_phot_properties(target, source, blend, RC, log)\\n\\n plot_colour_colour_diagram(params,star_catalog,catalog_header,\\n target, source, blend, RC,\\n det_idx,cat_idx,close_cat_idx, log)\\n\\n (source, blend) = match_source_blend_isochrones(params,source,blend,log)\\n\\n (source, blend) = calc_source_blend_ang_radii(source, blend, log)\\n\\n (source, blend) = calc_source_blend_physical_radii(source, blend, log)\\n\\n (source,blend) = calc_source_blend_distance(source, blend, RC, log)\\n\\n lens = calc_lens_parameters(params, source, RC, log)\\n\\n output_red_clump_data_latex(params,RC,log)\\n\\n output_source_blend_data_latex(params,source,blend,log)\\n\\n output_lens_parameters_latex(params,source,lens,log)\",\n \"def meanRegion(thk_s,thk_p,thk_diff):\\n meanp = np.nanmean(np.nanmean(thk_p,axis=1),axis=1)\\n means = np.nanmean(np.nanmean(thk_s,axis=1),axis=1)\\n \\n print '\\\\n --- [[%s to %s N, %s to %s E]] ---' % (latmin,latmax,lonmin,lonmax)\\n print 'Average Thickness (Satellite) == %s meters' % np.nanmean(means)\\n print 'Average Thickness (PIOMAS) == %s meters' % np.nanmean(meanp)\\n print 'Average Difference == %s meters' % (np.nanmean(means)-np.nanmean(meanp))\\n \\n yearmin = 2004\\n yearmax = 2015\\n years = np.arange(yearmin,yearmax+1,1)\\n years = np.setdiff1d(years,[2010]) ### no satellite data in 2010\\n \\n fig = plt.figure()\\n ax = plt.subplot(111)\\n \\n ### Call parameters\\n plt.rcParams['text.usetex']=True\\n plt.rcParams['font.family'] = 'sans-serif'\\n plt.rcParams['font.sans-serif'] = 'Avant Garde'\\n \\n plt.plot(meanp,color='darkred',linewidth=2,linestyle='-',\\n label=r'PIOMAS')\\n plt.plot(means,color='forestgreen',linewidth=2,linestyle='-',\\n label=r'Satellite')\\n plt.axvline(6,color='k',linewidth=3,linestyle='-')\\n \\n labelsy = map(str,np.arange(0,6,1))\\n labelsx = map(str,years)\\n plt.xticks(np.arange(len(years)),labelsx)\\n plt.yticks(np.arange(0,6,1),labelsy)\\n plt.ylabel(r'\\\\textbf{Thickness (meters)}',fontsize=13)\\n \\n ### Adjust axes in time series plots \\n def adjust_spines(ax, spines):\\n for loc, spine in ax.spines.items():\\n if loc in spines:\\n spine.set_position(('outward', 10))\\n else:\\n spine.set_color('none') \\n if 'left' in spines:\\n ax.yaxis.set_ticks_position('left')\\n else:\\n ax.yaxis.set_ticks([])\\n \\n if 'bottom' in spines:\\n ax.xaxis.set_ticks_position('bottom')\\n else:\\n ax.xaxis.set_ticks([]) \\n \\n ### Adjust axes spines\\n adjust_spines(ax, ['left', 'bottom'])\\n ax.spines['top'].set_color('none')\\n ax.spines['right'].set_color('none')\\n plt.grid(color='b',zorder=1,alpha=0.3)\\n \\n plt.legend(shadow=False,fontsize=11,loc='upper right',\\n fancybox=True)\\n \\n plt.text(2,-0.8,r'\\\\textbf{ICESat}',fontsize=13)\\n plt.text(7.3,-0.8,r'\\\\textbf{PIOMAS}',fontsize=13)\\n \\n fig.suptitle(r'\\\\textbf{SIT Difference [Satellite - PIOMAS]}',fontsize=16)\\n plt.savefig(directoryfigure + 'test5_difftseries.png',dpi=300)\",\n \"def testStatisticsRamp(self):\\n\\n \\n nx = 101\\n ny = 64\\n img = afwImage.ImageF(afwGeom.Extent2I(nx, ny))\\n \\n z0 = 10.0\\n dzdx = 1.0\\n mean = z0 + (nx/2)*dzdx\\n stdev = 0.0\\n for y in range(ny):\\n for x in range(nx):\\n z = z0 + dzdx*x\\n img.set(x, y, z)\\n stdev += (z - mean)*(z - mean)\\n\\n stdev = math.sqrt(stdev/(nx*ny - 1))\\n \\n stats = afwMath.makeStatistics(img, afwMath.NPOINT | afwMath.STDEV | afwMath.MEAN)\\n testmean = stats.getValue(afwMath.MEAN)\\n teststdev = stats.getValue(afwMath.STDEV)\\n \\n self.assertEqual(stats.getValue(afwMath.NPOINT), nx*ny)\\n self.assertEqual(testmean, mean)\\n self.assertEqual(teststdev, stdev )\\n \\n stats = afwMath.makeStatistics(img, afwMath.STDEV | afwMath.MEAN | afwMath.ERRORS)\\n mean, meanErr = stats.getResult(afwMath.MEAN)\\n sd = stats.getValue(afwMath.STDEV)\\n \\n self.assertEqual(mean, img.get(nx/2, ny/2))\\n self.assertEqual(meanErr, sd/math.sqrt(img.getWidth()*img.getHeight()))\\n \\n # ===============================================================================\\n # sjb code for percentiles and clipped stats\\n \\n stats = afwMath.makeStatistics(img, afwMath.MEDIAN)\\n self.assertEqual(z0 + dzdx*(nx - 1)/2.0, stats.getValue(afwMath.MEDIAN))\\n \\n stats = afwMath.makeStatistics(img, afwMath.IQRANGE)\\n self.assertEqual(dzdx*(nx - 1)/2.0, stats.getValue(afwMath.IQRANGE))\\n \\n stats = afwMath.makeStatistics(img, afwMath.MEANCLIP)\\n self.assertEqual(z0 + dzdx*(nx - 1)/2.0, stats.getValue(afwMath.MEANCLIP))\",\n \"def repeat(start, end, roi_times=None, timeres=2, coords=None, ar=None,\\n split_temps=None, em_wlen=None, plotminmax=False, plotstd=False,\\n hist_type='plain', loaddata=False):#, output=None):\\n #if isinstance(output, str):\\n # from matplotlib import use\\n # use(output)\\n import matplotlib.pyplot as plt\\n import matplotlib.dates as mdates\\n\\n #loaddata = False\\n\\n print start, end\\n start, end = parse(start), parse(end)\\n \\n s = []\\n t = []\\n p = []\\n \\n #if flares == []:\\n # return s, t, p\\n\\n timerange = tr(start, end)\\n delta = dt.timedelta(hours=timeres)\\n ntimes = int(timerange.seconds()/delta.total_seconds())\\n times = [time.start() for time in timerange.split(ntimes)]\\n \\n ntemps = 141\\n tempsovertime = np.zeros((ntemps, ntimes))\\n \\n means = np.zeros(len(times))\\n p95s = np.zeros(len(times))\\n loopmeans = np.zeros(len(times))\\n if plotminmax:\\n maxes = np.zeros(len(times))\\n mins = np.zeros(len(times))\\n if plotstd:\\n stds = np.zeros(len(times))\\n loopstds = np.zeros(len(times))\\n if em_wlen:\\n meanem = np.zeros(len(times))\\n if plotminmax:\\n maxem = np.zeros(len(times))\\n minem = np.zeros(len(times))\\n if plotstd:\\n stdem = np.zeros(len(times))\\n\\n for i, date in enumerate(times):\\n data_only = True\\n try:\\n if ar == 'all':\\n plotar = None\\n else:\\n plotar = ar\\n results = output_maps(date, plotar, coords, 'data', split_temps,\\n subimsize=50, calc_em=em_wlen, data_only=data_only)#True)#, linear=True)\\n if isinstance(results, tuple):\\n tempmap, emmap = results\\n else:\\n tempmap = results\\n data = tempmap.data\\n except DownloadError as de:\\n data = np.zeros((512, 512))\\n print de.msg\\n except:\\n print 'KHAAAAAAAN! Some part of the temperature-plotting process failed.'\\n raise\\n data = np.zeros((512, 512))\\n if em_wlen:\\n emmap = np.zeros((512, 512))\\n \\n t.append(np.nanmean(data))\\n p.append(np.nanmax(data))\\n \\n data = data.flatten()\\n data2 = data.copy()\\n data2[data == 0.0] = np.NaN\\n data2 = data2[np.isfinite(data)]\\n data2.sort()\\n temps, bins = np.histogram(data, bins=ntemps, density=False, range=(5.6, 7.0))\\n temps = (temps/float(data.size))*100.0\\n tempsovertime[:, i] = temps\\n\\n #loops = data[data >= split_temps]\\n #data = data[data < split_temps]\\n\\n means[i] = np.nanmean(data2)\\n try:\\n p95s[i] = data2[round(0.95 * len(data2))-1]\\n except IndexError:\\n p95s[i] = np.NaN\\n #loopmeans[i] = np.nanmean(loops)\\n if plotminmax:\\n maxes[i] = np.nanmax(data)\\n mins[i] = np.nanmin(data)\\n if em_wlen:\\n maxem[i] = np.nanmax(emmap)\\n minem[i] = np.nanmin(emmap)\\n if plotstd:\\n stds[i] = np.nanstd(data)\\n if em_wlen:\\n stdem[i] = np.nanstd(emmap)\\n #loopstds[i] = np.nanstd(loops)\\n \\n tempsovertime[tempsovertime <= 0.1] = np.nan\\n\\n xmin, xmax = mdates.datestr2num([str(start), str(end)])\\n fig = plt.figure(figsize=(36, 18))\\n ax = fig.add_subplot(111, axisbg='k')\\n plot_title = 'Temperature distribution of corona\\\\n{:%Y/%m/%d %H:%M} - {:%Y/%m/%d %H:%M}'.format(start, end)\\n if roi_times:\\n plot_title += '\\\\nRegion observed: {:%Y/%m/%d %H:%M} - {:%Y/%m/%d %H:%M}'.format(*roi_times)\\n plt.title(plot_title)\\n if hist_type == 'plain':\\n plt.imshow(tempsovertime[30:106, :], extent=[xmin, xmax, 5.9, 6.65],\\n aspect='auto', interpolation='none', origin='lower',\\n cmap='coolwarm', vmin=np.nanmin(tempsovertime[65:106, :]),\\n vmax=np.nanmax(tempsovertime[65:106, :]))\\n elif hist_type == 'loops':\\n plt.imshow(tempsovertime[65:106, :], extent=[xmin, xmax, 6.25, 6.65],\\n aspect='auto', interpolation='none', origin='lower',\\n cmap='coolwarm', vmin=np.nanmin(tempsovertime[65:106, :]),\\n vmax=np.nanmax(tempsovertime[65:106, :]))\\n elif hist_type == 'full':\\n plt.imshow(tempsovertime, extent=[xmin, xmax, 5.6, 7.0],\\n aspect='auto', interpolation='none', origin='lower',\\n cmap='coolwarm', vmin=np.nanmin(tempsovertime),\\n vmax=np.nanmax(tempsovertime))\\n plt.tight_layout()\\n ax.xaxis_date()\\n fig.autofmt_xdate()\\n plt.colorbar(orientation='horizontal')\\n plt.savefig('/media/huw/temp-time_hists/distribution_over_time_{}'.format(ar))\\n plt.close()\\n\\n\\n means[np.where(means == 0.0)] = np.nan\\n if plotstd:\\n stds[np.where(stds == 0.0)] = np.nan\\n loopstds[loopstds == 0.0] = np.nan\\n\\n try:\\n tnums = mdates.date2num([ti for ti in times])\\n print maxes\\n print len(maxes)\\n fig = plt.figure(figsize=(18, 14))\\n ax = fig.add_subplot(111)\\n plt.title('Variation of temperature over time; AR{}'.format(ar), \\n fontsize=32)\\n plt.plot(tnums, maxes, label='Maximum temperature', color='red')\\n plt.axhline(np.nanmean(maxes))\\n print tnums\\n print len(tnums)\\n ax.xaxis_date()\\n fig.autofmt_xdate()\\n plt.legend(loc=4, fontsize=16)\\n plt.xlabel('Date', fontsize=24)\\n plt.ylabel('log(T)', fontsize=24)\\n #plt.savefig('/media/huw/temp_plots/temp_plot_{}_b'.format(ar))\\n plt.savefig('/home/drew/Dropbox/ARs/temps_{}_b'.format(ar))\\n plt.close()\\n\\n \\\"\\\"\\\"diff = ((maxes-p95s)/p95s)*100.0\\n fig = plt.figure(figsize=(18, 14))\\n ax = fig.add_subplot(1, 1, 1)\\n plt.title('Percentage difference between max and 95th %-ile; AR{}'.format(ar), \\n fontsize=32)\\n plt.plot(tnums, diff, color='black')\\n plt.scatter(fldates, [np.nanmax(diff)]*len(fldates))\\n for flare in flares:\\n ax.text(sunpy.time.parse_time(flare['event_peaktime']), np.nanmax(diff)+0.01, flare['fl_goescls'][0])\\n ax.xaxis_date()\\n fig.autofmt_xdate()\\n plt.xlabel('Date', fontsize=24)\\n plt.ylabel('log(T)', fontsize=24)\\n #plt.savefig('/media/huw/temp_plots/temp_plot_{}'.format(ar))\\n plt.savefig('Dropbox/ARs/diffs_{}'.format(ar))\\n plt.close()\\\"\\\"\\\"\\n \\n except:# ValueError:\\n print \\\"Can't plot the temperature graph because matplotlib is being a whiney douche\\\"\\n print tnums\\n raise\\n\\n return s, t, p, times\",\n \"def compare_ratios(path='/Volumes/OptiHDD/data/pylith/3d/agu2013/output',\\n\\t\\t\\t\\tsteps=['step01','step02'],\\n\\t\\t\\t\\t#labels='',\\n\\t\\t\\t\\tshow=True,\\n\\t\\t\\t\\txscale=1e3,\\n\\t\\t\\t\\tyscale=1e-2):\\n\\tplt.figure()\\n\\t#path = '/Users/scott/Desktop/elastic'\\n\\n\\t# Deep source\\n\\tlabels = ['no APMB', 'APMB']\\n\\tdeep = {}\\n\\tuzmax = 0.824873455364\\n\\t# NOT sure why hardcoded...\\n\\tuzmax = 1\\n\\tfor i,outdir in enumerate(steps):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 30.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'o-',ms=4,lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'o--',ms=4,lw=4,color=l.get_color()) #mfc='none' transparent\\n\\t\\tdeep[outdir] = uz_fem/uz_fem\\n\\n\\n\\t# Shallow Source\\n\\tshallow = {}\\n\\tuzmax = 0.949652827795 # Why?\\n\\tfor i,outdir in enumerate(['step11','step12']):\\n\\t\\tpointsFile = os.path.join(path, outdir, 'points.h5')\\n\\n\\t\\tx,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n\\n\\t\\tX = x / xscale\\n\\t\\tY1 = ux / yscale\\n\\n\\t\\tx_fem = X #/ xscale #double scaling!\\n\\t\\tur_fem = Y1 #/ yscale\\n\\t\\tuz_fem = uz / yscale\\n\\n\\t\\t#print(pointsFile)\\n\\t\\tprint(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max(), uz_fem.max() / ur_fem.max())\\n\\n\\t\\t#normalize\\n\\t\\tuz_fem = uz_fem / uzmax\\n\\t\\tur_fem = ur_fem / uzmax\\n\\t\\tx_fem = x_fem / 20.0\\n\\n\\t\\tl, = plt.plot(x_fem,uz_fem,'.-', mfc='w', lw=4,label=labels[i])\\n\\t\\tplt.plot(x_fem,ur_fem,'.--',lw=4, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n\\t\\tshallow[outdir] = uz_fem/ur_fem\\n\\n\\t# Annotate\\n\\tplt.axhline(color='k',lw=0.5)\\n\\t#plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n\\t#plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n\\tplt.legend()\\n\\tplt.grid()\\n\\t#plt.ylim(-0.5, 3.5)\\n\\t#plt.savefig('deep.png',bbox_inches='tight')\\n\\t#plt.savefig('shallow.png',bbox_inches='tight')\\n\\n\\t# normalized\\n\\tplt.ylim(-0.5, 4)\\n\\tplt.xlim(0,10)\\n\\tplt.xlabel('Normalized Radial Distance [R / D]')\\n\\tplt.ylabel('Normalized Displacement [U / Uz_max]')\\n\\t#plt.savefig('normalized_deep.png',bbox_inches='tight')\\n\\tplt.savefig('normalized_shallow.png',bbox_inches='tight')\\n\\n\\n\\t# Plot ratios of uz versus NOTE: this plot is confusing,,, just keep ratio of uz_max to ur_max\\n\\t'''\\n\\tplt.figure()\\n\\tplt.plot(x_fem, deep['step01'], label='Deep no APMB')\\n\\tplt.plot(x_fem, deep['step02'], label='Deep w/ APMB')\\n\\tplt.plot(x_fem, shallow['step11'], label='Shallow no APMB')\\n\\tplt.plot(x_fem, shallow['step12'], label='Shallow w/ APMB')\\n\\tplt.xlabel('Distance [km]') #NOTE: maybe plot normailzed X-axis (R-d)\\n\\t#plt.xlabel('Normalized Distance [R/d]')\\n\\tplt.ylabel('Ratio [Uz/Ur]')\\n\\tplt.title('Ratio of vertical to radial displacement')\\n\\tplt.legend()\\n\\tplt.show()\\n\\t'''\",\n \"def radiation_measurement_analysis():\\n import pint\\n ureg = pint.UnitRegistry()\\n\\n mrem_h = ureg.parse_units('mrem') / ureg.hour\\n m = ureg.parse_units('meters')\\n s = ureg.parse_units('seconds')\\n\\n # Measurements of background radiation\\n bg_dist = ureg.parse_expression('10 m') # estimate of how far away we are wrt background\\n background_rows = [\\n dict(vid=1, distance=bg_dist, rad=0.023 * mrem_h, capture_time=0.0 * s),\\n dict(vid=1, distance=bg_dist, rad=0.022 * mrem_h, capture_time=0.0 * s),\\n dict(vid=1, distance=bg_dist, rad=0.023 * mrem_h, capture_time=4.0 * s),\\n dict(vid=1, distance=bg_dist, rad=0.021 * mrem_h, capture_time=5.0 * s),\\n dict(vid=1, distance=bg_dist, rad=0.023 * mrem_h, capture_time=11.0 * s),\\n dict(vid=1, distance=bg_dist, rad=0.023 * mrem_h, capture_time=16.0 * s),\\n dict(vid=1, distance=bg_dist, rad=0.024 * mrem_h, capture_time=20.0 * s),\\n ]\\n\\n # Measurements of sample radiation\\n esp_dist = ureg.parse_expression('1 inch').to(m) / 2 # estimate of how far we are from the sample when very close\\n dist0_rows = [\\n dict(vid=2, distance=esp_dist, rad=0.060 * mrem_h, capture_time=0.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.061 * mrem_h, capture_time=3.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.060 * mrem_h, capture_time=5.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.059 * mrem_h, capture_time=9.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.060 * mrem_h, capture_time=10.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.059 * mrem_h, capture_time=11.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.057 * mrem_h, capture_time=12.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.058 * mrem_h, capture_time=13.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.059 * mrem_h, capture_time=14.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.060 * mrem_h, capture_time=15.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.061 * mrem_h, capture_time=16.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.062 * mrem_h, capture_time=18.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.062 * mrem_h, capture_time=18.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.064 * mrem_h, capture_time=20.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.065 * mrem_h, capture_time=22.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.066 * mrem_h, capture_time=23.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.065 * mrem_h, capture_time=24.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.063 * mrem_h, capture_time=25.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.065 * mrem_h, capture_time=26.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.064 * mrem_h, capture_time=27.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.064 * mrem_h, capture_time=27.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.065 * mrem_h, capture_time=28.0 * s),\\n dict(vid=2, distance=esp_dist, rad=0.063 * mrem_h, capture_time=30.0 * s),\\n ]\\n\\n dist0_v2_rows = [\\n dict(vid=3, distance=esp_dist, rad=0.012 * mrem_h, capture_time=0.0 * s),\\n dict(vid=3, distance=esp_dist, rad=0.011 * mrem_h, capture_time=1.0 * s),\\n dict(vid=3, distance=esp_dist, rad=0.013 * mrem_h, capture_time=8.0 * s),\\n dict(vid=3, distance=esp_dist, rad=0.013 * mrem_h, capture_time=9.0 * s),\\n ]\\n\\n close_rows = [\\n dict(vid=4, distance=0.5 * m, rad=0.013 * mrem_h, capture_time=0.0 * s),\\n dict(vid=4, distance=0.5 * m, rad=0.014 * mrem_h, capture_time=5.0 * s),\\n dict(vid=4, distance=0.5 * m, rad=0.012 * mrem_h, capture_time=7.0 * s),\\n dict(vid=4, distance=0.5 * m, rad=0.011 * mrem_h, capture_time=15.0 * s),\\n dict(vid=4, distance=0.5 * m, rad=0.012 * mrem_h, capture_time=16.0 * s),\\n ]\\n\\n mid_rows = [\\n dict(vid=5, distance=1.0 * m, rad=0.014 * mrem_h, capture_time=0.0 * s),\\n dict(vid=5, distance=1.0 * m, rad=0.015 * mrem_h, capture_time=5.0 * s),\\n dict(vid=5, distance=1.0 * m, rad=0.013 * mrem_h, capture_time=10.0 * s),\\n ]\\n\\n far_rows = [\\n dict(vid=6, distance=2.0 * m, rad=0.023 * mrem_h, capture_time=0.0 * s),\\n dict(vid=6, distance=2.0 * m, rad=0.025 * mrem_h, capture_time=0.1 * s),\\n ]\\n\\n # guess_dist = ureg.parse_expression('0.3 m') # estimate of how far away we are wrt background\\n # guess_rows = [\\n # dict(vid=9, distance=guess_dist, rad=0.030 * mrem_h, capture_time=0.0 * s),\\n # dict(vid=9, distance=guess_dist, rad=0.041 * mrem_h, capture_time=2.0 * s),\\n # dict(vid=9, distance=guess_dist, rad=0.051 * mrem_h, capture_time=3.0 * s),\\n # ]\\n\\n rows = dist0_rows + background_rows + dist0_v2_rows + close_rows + mid_rows + far_rows\\n # rows += guess_rows\\n\\n import pandas as pd\\n import numpy as np\\n table = pd.DataFrame(rows)\\n\\n # Ensure comparable units\\n units = {\\n 'rad': mrem_h,\\n 'distance': m,\\n 'capture_time': s,\\n }\\n for key, unit in units.items():\\n table[key] = table[key].apply(lambda c: c.to(unit).m)\\n table['rad'] = table['rad'].astype(float)\\n table['distance'] = table['distance'].astype(float)\\n\\n # Weight each measurement based on the amount of time the measurement was\\n # sustained in the video.\\n average_rad_rows = []\\n for vid, group in table.groupby('vid'):\\n from statsmodels.stats.weightstats import DescrStatsW\\n weights = (-1 * group['capture_time'].diff(periods=-1).fillna(0)) / group['capture_time'].iloc[-1]\\n table.loc[group.index, 'weight'] = weights\\n values = group['rad']\\n weighted_stats = DescrStatsW(values, weights=weights, ddof=0)\\n dists = group['distance'].unique()\\n assert len(dists) == 1\\n average_rad_rows.append({\\n 'vid': vid,\\n 'distance': dists[0],\\n 'rad_mean': weighted_stats.mean,\\n 'rad_std': weighted_stats.std,\\n })\\n stats_table = pd.DataFrame(average_rad_rows)\\n\\n bg_row = stats_table.loc[stats_table['distance'].argmax()]\\n fg_row = stats_table.loc[stats_table['distance'].argmin()]\\n\\n # -------------------\\n ADD_DUMMY_VALUES = 0\\n if ADD_DUMMY_VALUES:\\n # Hack: because we don't have enough samples we can fudge the value\\n # knowning that the value should be the background radiation in the\\n # limit.\\n\\n dummy_measurements = []\\n extra_support = 1\\n for idx in range(3, 3 + extra_support):\\n dummy_row = {\\n 'vid': -idx,\\n 'distance': bg_row['distance'] + idx,\\n 'rad_mean': bg_row['rad_mean'],\\n 'rad_std': 0.01,\\n }\\n dummy_measurements.append(dummy_row)\\n\\n # also add an extra value close to the sample\\n rad_bg = bg_row['rad_mean']\\n rad_above_bg = fg_row['rad_mean'] - rad_bg\\n dummy_row = {\\n 'vid': -1,\\n 'distance': fg_row['distance'] / 2,\\n 'rad_mean': rad_bg + (rad_above_bg * 4),\\n 'rad_std': 0.5,\\n }\\n dummy_measurements.append(dummy_row)\\n\\n # dummy_row = {\\n # 'vid': -2,\\n # 'distance': fg_row['distance'] / 4,\\n # 'rad_mean': rad_bg + (rad_above_bg * 16),\\n # }\\n # dummy_measurements.append(dummy_row)\\n\\n dummy_stats = pd.DataFrame(dummy_measurements)\\n dummy_stats['weight'] = 0.5\\n stats_table['weight'] = 1.0\\n stats_table2 = pd.concat([stats_table, dummy_stats]).reset_index(drop=True).sort_values('distance')\\n else:\\n stats_table2 = stats_table\\n # -------------------\\n\\n import scipy\\n scipy.optimize.curve_fit\\n\\n # Because we know the radiation should follow an inverse square law wrt to\\n # distance, we can fit a polynomial of degree 2 (parabola) to interpolate /\\n # extrapolate the **inverse** values.\\n x = stats_table2['distance'].values\\n y = stats_table2['rad_mean'].values\\n s = stats_table2['rad_std'].values\\n\\n # Model the squared falloff directly\\n def invsquare(x, a, b):\\n return a * (1 / (0.01 + x ** 2)) + b\\n # bg_row['rad_mean']\\n # Use curve_fit to constrain the first coefficient to be zero\\n try:\\n coef = scipy.optimize.curve_fit(invsquare, x, y, sigma=s, method='trf')[0]\\n except Exception as ex:\\n coef = None\\n print(f'ex={ex}')\\n\\n # Also fit one to the raw weighted points as a sanity check\\n # inv_poly2 = Polynomial.fit(table['distance'], 1 / table['rad'], w=table['weight'], deg=2)\\n\\n import kwplot\\n sns = kwplot.autosns()\\n plt = kwplot.autoplt()\\n # ax = sns.boxplot(data=table, x='distance', y='rad', width=0.1)\\n\\n # Add in points to show each observation\\n ax = sns.relplot(x=\\\"distance\\\", y=\\\"rad\\\", data=table, size=4, color=\\\".3\\\",\\n linewidth=0, alpha=0.5, palette='deep')\\n\\n ax = plt.gca()\\n ax.set_xlabel('distance from sample ({})'.format(str(units['distance'])))\\n ax.set_ylabel('radiation dosage ({})'.format(str(units['rad'])))\\n\\n max_meters = 10\\n\\n extrap_x = np.linspace(0, max_meters, 1000)\\n if coef is not None:\\n extrap_y1 = invsquare(extrap_x, *coef)\\n # extrap_y2 = 1 / inv_poly2(extrap_x)\\n ax.plot(stats_table2['distance'].values, stats_table2['rad_mean'].values, 'rx')\\n ax.plot(stats_table['distance'].values, stats_table['rad_mean'].values, 'bo')\\n ax.plot(extrap_x, extrap_y1, '--')\\n ax.set_ylim(0.001, 0.1)\\n ax.set_yscale('log')\\n # ax.plot(extrap_x, extrap_y2, '--')\",\n \"def update_and_calculate(self, value):\\r\\n retval = -1\\r\\n diff = abs(self.ewma - value)\\r\\n if self.n >= 5: # only calculate meandevs if collected > 5 data pts.\\r\\n if self.ewmmd > 0:\\r\\n meandevs = diff/self.ewmmd\\r\\n else:\\r\\n meandevs = diff/.00001\\r\\n retval = meandevs\\r\\n \\r\\n # update ewma/ewmmd\\r\\n self.n += 1\\r\\n if self.n > 1:\\r\\n if self.n > 2:\\r\\n self.ewmmd = (.125*diff) + (.875*self.ewmmd)\\r\\n else:\\r\\n self.ewmmd = diff\\r\\n self.ewma = (.125*value) + (.875*self.ewma)\\r\\n else:\\r\\n self.ewma = value\\r\\n return retval\",\n \"def avg_data_each_h(nof, lof, x_vel, y_vel, z_vel):\\n sx_vel = []\\n sy_vel = []\\n sz_vel = []\\n\\n for i in range(lof):\\n sx = 0\\n sy = 0\\n sa = 0\\n for j in range(nof):\\n sx += x_vel[i + (j * nof)]\\n sy += y_vel[i + (j * nof)]\\n sa += z_vel[i + (j * nof)]\\n\\n sx_vel.append(sx)\\n sy_vel.append(sy)\\n sz_vel.append(sa)\\n\\n # checks lengths match and then averages them and returns the average velocities\\n if len(sx_vel) == len(sy_vel) and len(sx_vel) == len(sz_vel):\\n if len(sx_vel) == lof:\\n ax_vel = np.array(sx_vel) / nof\\n ay_vel = np.array(sy_vel) / nof\\n az_vel = np.array(sz_vel) / nof\\n\\n return ax_vel, ay_vel, az_vel\\n else:\\n print \\\"Error: summed velocity array is the wrong length!\\\"\\n else:\\n print \\\"Error: summed velocity data not matching!\\\"\",\n \"def msaa(self, factor=2):\\n from .detector import bindown\\n x, y, data = self.x, self.y, self.data\\n data = bindown(data, factor, factor, 'avg')\\n self.data = data\\n self.x = x[::factor]\\n self.y = y[::factor]\\n return self\",\n \"def EstimatedAutocorr(fw, data, pnum, trialnum, marker1, marker2): \\n cycle_start = HeelStrike(fw, data, pnum, trialnum, marker1, marker2)\\n x = cycle_start[2] \\n time = cycle_start[1]\\n drop_NA = np.vstack((x, time))\\n #print drop_NA.shape, x.shape, y.shape\\n drop_NA = drop_NA.T\\n x = drop_NA[:,0]\\n #x = x[~np.isnan(x).any()]\\n \\n #n = len(x)\\n #var = np.var(x)\\n tao = np.correlate(x, x, mode='full')\\n # assert np.allclose(r, np.array([(x[:n-k]*x[-(n-k):]).sum() for k in range(n)]))\\n #result = r/(var*(np.arange(n, 0, -1)))\\n plt.figure(4)\\n plt.plot(tao)\\n return tao\",\n \"def preCalibrate(self):\\n self._write_enabled = False\\n self.start_recording()\\n\\n origin = (int(self.disp.dispsize[0] / 4), int(self.disp.dispsize[1] / 4))\\n size = (int(2 * self.disp.dispsize[0] / 4), int(2 * self.disp.dispsize[1] / 4))\\n\\n videoFile = os.path.join(c.CALIBVIDEODIR, \\\"--- cal_movie_1.mov\\\")\\n\\n # Initialise a PsychoPy MovieStim\\n mov = visual.MovieStim3(self.video_win, videoFile, flipVert=False)\\n\\n print(\\\"------------> Pre-calibration process started.\\\")\\n print(\\\"------------> When correctly positioned press \\\\'space\\\\' to start the calibration.\\\")\\n\\n while mov.status != visual.FINISHED:\\n if not self.gaze:\\n continue\\n\\n self.screen.clear()\\n\\n # Add the MovieStim to a PyGaze Screen instance.\\n self.screen.screen.append(mov)\\n\\n gaze_sample = copy.copy(self.gaze[-1])\\n\\n validity_colour = (255, 0, 0)\\n\\n if gaze_sample['right_gaze_origin_validity'] and gaze_sample['left_gaze_origin_validity']:\\n left_validity = 0.15 < gaze_sample['left_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\\n right_validity = 0.15 < gaze_sample['right_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\\n if left_validity and right_validity:\\n validity_colour = (0, 255, 0)\\n\\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0] + size[0], origin[1]), pw=1)\\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0], origin[1] + size[1]), pw=1)\\n self.screen.draw_line(colour=validity_colour,\\n spos=(origin[0], origin[1] + size[1]),\\n epos=(origin[0] + size[0], origin[1] + size[1]),\\n pw=1)\\n self.screen.draw_line(colour=validity_colour,\\n spos=(origin[0] + size[0], origin[1] + size[1]),\\n epos=(origin[0] + size[0], origin[1]),\\n pw=1)\\n\\n right_eye, left_eye, distance = None, None, []\\n if gaze_sample['right_gaze_origin_validity']:\\n distance.append(round(gaze_sample['right_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\\n right_pos = gaze_sample['right_gaze_origin_in_trackbox_coordinate_system']\\n right_eye = ((1 - right_pos[0]) * size[0] + origin[0], right_pos[1] * size[1] + origin[1])\\n self.screen.draw_circle(colour=validity_colour,\\n pos=right_eye,\\n r=int(self.disp.dispsize[0] / 100),\\n pw=5,\\n fill=True)\\n\\n if gaze_sample['left_gaze_origin_validity']:\\n distance.append(round(gaze_sample['left_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\\n left_pos = gaze_sample['left_gaze_origin_in_trackbox_coordinate_system']\\n left_eye = ((1 - left_pos[0]) * size[0] + origin[0], left_pos[1] * size[1] + origin[1])\\n self.screen.draw_circle(colour=validity_colour,\\n pos=left_eye,\\n r=int(self.disp.dispsize[0] / 100),\\n pw=5,\\n fill=True)\\n\\n self.screen.draw_text(text=\\\"Current distance to the eye tracker: {0} cm.\\\".format(self._mean(distance)),\\n pos=(int(self.disp.dispsize[0] / 2), int(self.disp.dispsize[1] * 0.9)),\\n colour=(255, 255, 255),\\n fontsize=20)\\n\\n self.disp.fill(self.screen)\\n self.disp.show()\\n\\n key = self._getKeyPress()\\n if key == \\\"space\\\":\\n break\\n\\n\\n\\n if mov.status != visual.FINISHED:\\n # pause and discard video for the audio to stop as well\\n mov.pause()\\n self.screen.screen.remove(mov)\\n #video_win.close()\\n del mov\\n self.screen.clear()\\n clock.pause(1000)\\n return True\\n else:\\n return False\",\n \"def estimate_running_each_trial(running_trace, trial_onset, smoothsize=10, presamples=4,\\n threshold=3, showfig=False):\\n smoothwin = np.ones(smoothsize)/(smoothsize)\\n running_trace_smooth = np.convolve(running_trace, smoothwin, mode='same')\\n trial_onset_ind = np.where(trial_onset)[0]\\n presamples_inds = np.arange(-presamples, 0) + trial_onset_ind[:, np.newaxis]\\n pretrial_avg = running_trace_smooth[presamples_inds].mean(axis=1)\\n running_each_trial = pretrial_avg > threshold\\n if showfig:\\n plt.cla()\\n plt.plot(running_trace_smooth, '0.8')\\n plt.plot(trial_onset_ind, pretrial_avg, 'xg')\\n plt.plot(trial_onset_ind, running_each_trial*running_trace_smooth.max(), 'og')\\n plt.axhline(threshold, color='k')\\n plt.legend(['running_trace_smooth', 'pretrial_avg', 'running_each_trial'],\\n loc='upper right')\\n plt.show()\\n return running_each_trial, running_trace_smooth\",\n \"def event(self, evt, env):\\n\\n super(mod_radial_average, self).event(evt, env)\\n if (evt.get(\\\"skip_event\\\")):\\n return\\n\\n # This module only applies to detectors for which a distance is\\n # available.\\n distance = cspad_tbx.env_distance(self.address, env, self._detz_offset)\\n if distance is None:\\n self.nfail += 1\\n self.logger.warning(\\\"event(): no distance, shot skipped\\\")\\n evt.put(skip_event_flag(), \\\"skip_event\\\")\\n return\\n\\n # See r17537 of mod_average.py.\\n device = cspad_tbx.address_split(self.address)[2]\\n if device == 'Cspad':\\n pixel_size = cspad_tbx.pixel_size\\n saturated_value = cspad_tbx.cspad_saturated_value\\n elif device == 'marccd':\\n pixel_size = 0.079346\\n saturated_value = 2**16 - 1\\n elif device == 'Rayonix':\\n pixel_size = rayonix_tbx.get_rayonix_pixel_size(self.bin_size)\\n saturated_value = rayonix_tbx.rayonix_saturated_value\\n\\n d = cspad_tbx.dpack(\\n active_areas=self.active_areas,\\n address=self.address,\\n beam_center_x=pixel_size * self.beam_center[0],\\n beam_center_y=pixel_size * self.beam_center[1],\\n data=self.cspad_img.iround(), # XXX ouch!\\n distance=distance,\\n pixel_size=pixel_size,\\n saturated_value=saturated_value,\\n timestamp=self.timestamp,\\n wavelength=self.wavelength,\\n xtal_target=self.m_xtal_target)\\n\\n from xfel.command_line.radial_average import run\\n args = [\\n \\\"file_path=XTC stream\\\",\\n \\\"xfel_target=%s\\\"%self.m_xtal_target,\\n \\\"verbose=False\\\"\\n ]\\n\\n t = self.timestamp\\n s = t[0:4] + t[5:7] + t[8:10] + t[11:13] + t[14:16] + t[17:19] + t[20:23]\\n\\n if self._dirname is not None:\\n dest_path = os.path.join(self._dirname, self._basename + s + \\\".txt\\\")\\n args.append(\\\"output_file=%s\\\"%dest_path)\\n\\n self.logger.info(\\\"Calculating radial average for image %s\\\"%s)\\n xvals, results = run(args, d)\\n\\n evt.put(xvals, \\\"cctbx.xfel.radial_average.xvals\\\")\\n evt.put(results, \\\"cctbx.xfel.radial_average.results\\\")\\n\\n def get_closest_idx(data, val):\\n from scitbx.array_family import flex\\n deltas = flex.abs(data - val)\\n return flex.first_index(deltas, flex.min(deltas))\\n\\n if self._two_theta_low is not None:\\n i_low = results[get_closest_idx(xvals, self._two_theta_low)]\\n evt.put(i_low, \\\"cctbx.xfel.radial_average.two_theta_low\\\")\\n\\n if self._two_theta_high is not None:\\n i_high = results[get_closest_idx(xvals, self._two_theta_high)]\\n evt.put(i_high, \\\"cctbx.xfel.radial_average.two_theta_high\\\")\",\n \"def running_mean(self,windowlength=3*86400.0,overlap=12*3600.0, plot=True):\\r\\n \\r\\n # Make sure that omega is a list\\r\\n\\r\\n pt1,pt2 = window_index_time(self.t,windowlength,overlap)\\r\\n npt = len(pt1)\\r\\n tmid = []\\r\\n ymean = np.zeros((npt,))\\r\\n yrms = np.zeros((npt,))\\r\\n\\r\\n ii=-1\\r\\n for t1,t2 in zip(pt1,pt2):\\r\\n ii+=1\\r\\n\\r\\n ymean[ii] = self.y[t1:t2].mean()\\r\\n yrms[ii] = crms(self.tsec[t1:t2],self.y[t1:t2]-ymean[ii])\\r\\n \\r\\n # Return the mid time point\\r\\n ind = np.floor(t1 + (t2-t1)/2)\\r\\n tmid.append(self.t[ind])\\r\\n \\r\\n tmid = np.asarray(tmid)\\r\\n \\r\\n if plot:\\r\\n plt.subplot(211)\\r\\n self.plot()\\r\\n plt.plot(tmid,ymean,'r')\\r\\n plt.fill_between(tmid,ymean-yrms,y2=ymean+yrms,color=[0.5,0.5,0.5],alpha=0.5)\\r\\n plt.legend(('Original Signal','Mean','$\\\\pm$ RMS'))\\r\\n \\r\\n ax=plt.subplot(212)\\r\\n plt.fill_between(tmid,yrms,alpha=0.7)\\r\\n plt.xticks(rotation=17)\\r\\n plt.ylabel('RMS')\\r\\n ax.set_xlim([self.t[0],self.t[-1]])\\r\\n \\r\\n \\r\\n return tmid, ymean, yrms\",\n \"def calculate_metrics(self):\\n\\n # from the roi pixels we calculate the offset from the camera if the car\\n # is at middle --> ie. half bottom roi with is 0\\n x_center = (self.roi_warped_points[0][0] + \\\\\\n (self.roi_warped_points[1][0] - self.roi_warped_points[0][0]) / 2) * self.xm_per_pix\\n\\n # calculate the base point (near the car) with respect to the ROI\\n base_fitx = self.best_fit[0]*self.roi_warped_points[2][1]**2 + \\\\\\n self.best_fit[1]*self.roi_warped_points[2][1] + \\\\\\n self.best_fit[2]\\n\\n # calculate the base point for the line in m according to the camera\\n # as origin point\\n self.line_base_pos = base_fitx * self.xm_per_pix - x_center\\n\\n # calculate the radius of the curvature by fitting a polynom through\\n # the current X and Y points in real world units\\n fit_cr = np.polyfit(self.ally * self.ym_per_pix, self.allx * self.xm_per_pix, 2)\\n\\n self.radius_of_curvature = ((1 + (2*fit_cr[0]*719*self.ym_per_pix + \\\\\\n fit_cr[1])**2)**1.5) / np.absolute(2*fit_cr[0])\",\n \"def calibrate_file(self, calibration_slope, calibration_offset):\\n\\n self.data.average_spectrum = (calibration_slope * self.data.average_spectrum \\n + calibration_offset)\\n\\n individual_wavelength = np.zeros(2048)\\n individual_slope = np.zeros(2048)\\n individual_offset = np.zeros(2048)\\n\\n for i_wavelength in range(2048):\\n individual_wavelength[i_wavelength] = self.data.wavelength[\\n i_wavelength * self.header.zero_fill]\\n individual_slope[i_wavelength] = calibration_slope[\\n i_wavelength * self.header.zero_fill]\\n individual_offset[i_wavelength] = calibration_offset[\\n i_wavelength * self.header.zero_fill]\\n\\n index = np.argsort(individual_wavelength)\\n individual_wavelength = individual_wavelength[index]\\n self.data.individual_wavelength = individual_wavelength\\n average_spectrum = self.data.average_spectrum[index]\\n\\n i_min = np.argmin(abs(individual_wavelength - 8.0))\\n i_max = np.argmin(abs(individual_wavelength - 14.0))\\n\\n for i in range(self.header.number_of_coadds):\\n i_center_burst = np.argmax(np.absolute(self.data.interferogram[i]))\\n\\n size = self.header.interferogram_size\\n interferogram_shift = size/2 - i_center_burst\\n\\n self.data.interferogram[i] = np.roll(self.data.interferogram[i], \\n interferogram_shift)\\n self.data.interferogram[i] = self.data.interferogram[i][\\n size/2-2048:size/2+2048]\\n\\n window_fn = np.hanning(4096)\\n \\n spectrum = np.fft.fft(self.data.interferogram[i] * window_fn)\\n spectrum = spectrum/3300\\n spectrum = individual_slope * np.absolute(spectrum[0:2048]\\n ) + individual_offset\\n spectrum = spectrum[index]\\n\\n self.data.spectrum.append(spectrum)\",\n \"def __init__(self, roi_warped_points):\\n\\n # was the line detected in the last iteration?\\n self.detected = False\\n # x values of the last n fits of the line\\n self.recent_xfitted = []\\n #average x values of the fitted line over the last n iterations\\n self.bestx = None\\n #polynomial coefficients averaged over the last n iterations\\n self.best_fit = [np.array([False])]\\n #polinomial coefficients for the last n fits of the lane\\n self.recent_fit = []\\n #polynomial coefficients for the most recent fit\\n self.current_fit = [np.array([False])]\\n #radius of curvature of the line in some units\\n self.radius_of_curvature = 0\\n #distance in meters of vehicle center from the line\\n self.line_base_pos = 0\\n #difference in fit coefficients between last and new fits\\n self.diffs = np.array([0,0,0], dtype='float')\\n #x values for detected line pixels\\n self.allx = None\\n #maximum number of iterations to average\\n self.max_n = 10 #25\\n\\n # roi image points in bird's view space\\n self.roi_warped_points = roi_warped_points\\n\\n #y values for detected line pixels\\n self.ally = np.linspace(0, self.roi_warped_points[2][1] - 1, self.roi_warped_points[2][1])\\n\\n # line base pos is calculated through the roi information\\n # the used four point ROI has two points at the bottom that are straight\\n # with respect to the bottom - as this points are right next to the lines,\\n # they can be translated from pixels into meters with the knowledge of\\n # a U.S. highway standard lane - this is an apprximation, but should be\\n # good enough for this project\\n # U.S. regulations minimum lane width: 3.7m\\n self.xm_per_pix = 3.7 / (self.roi_warped_points[1][0] - self.roi_warped_points[0][0])\\n\\n # each dashed line is 3m long --> about 33m for warped image\\n self.ym_per_pix = 33 / (self.roi_warped_points[2][1] - self.roi_warped_points[0][1])\",\n \"def autoAnalyze(self):\\n print(\\\"Perfoming full automatic analysis...\\\")\\n t1=time.perf_counter()\\n self.cleanUp()\\n self.figure_rois()\\n self.figure_roi_inspect_all()\\n self.figure_dGoR_roi(showEach=False,saveAs=self.folderSave+\\\"/avg.png\\\")\\n self.figure_dGoR_roi(showEach=True,saveAs=self.folderSave+\\\"/each.png\\\")\\n self.index()\\n print(\\\"analysis completed in %.02f sec\\\"%(time.perf_counter()-t1))\",\n \"def data_vis():\\n dataroot = 'solar_data.txt'\\n debug = False \\n diff = False\\n X, y = read_data(dataroot, debug, diff)\\n\\n # First plot the original timeseries\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(y)\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(X[:,0])\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(X[:,1])\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(X[:,2])\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(X[:,3])\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(X[:,4])\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(X[:,5])\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##########################################################################################\\n # Plotting the Fourier Transform of the signals\\n\\n freq = np.fft.fftfreq(len(y), 1*60*60)\\n\\n fig = plt.figure(figsize=(40,40))\\n\\n fig.add_subplot(3,3,1)\\n plt.plot(freq, np.abs(np.fft.fft(y)))\\n plt.title('Avg Global PSP (vent/cor) [W/m^2]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,2)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,0])))\\n plt.title('Avg Zenith Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,3)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,1])))\\n plt.title('Avg Azimuth Angle [degrees]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,4)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,2])))\\n plt.title('Avg Tower Dry Bulb Temp [deg C]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,5)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,3])))\\n plt.title('Avg Tower RH [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,6)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,4])))\\n plt.title('Avg Total Cloud Cover [%]')\\n # plt.show()\\n\\n fig.add_subplot(3,3,7)\\n plt.plot(freq, np.abs(np.fft.fft(X[:,5])))\\n plt.title('Avg Avg Wind Speed @ 6ft [m/s]')\\n # plt.show()\\n\\n ##################################################################################################\\n # Print correlation matrix\\n\\n df = pd.DataFrame(np.c_[y, X])\\n df.columns = ['Avg Global PSP (vent/cor) [W/m^2]','Avg Zenith Angle [degrees]','Avg Azimuth Angle [degrees]','Avg Tower Dry Bulb Temp [deg C]','Avg Tower RH [%]','Avg Total Cloud Cover [%]','Avg Avg Wind Speed @ 6ft [m/s]']\\n f = plt.figure(figsize=(19, 15))\\n plt.matshow(df.corr(), fignum=f.number)\\n plt.xticks(range(df.shape[1]), df.columns, fontsize=14, rotation=20)\\n plt.yticks(range(df.shape[1]), df.columns, fontsize=14)\\n cb = plt.colorbar()\\n cb.ax.tick_params(labelsize=14)\\n plt.title('Correlation Matrix', fontsize=16);\\n plt.show()\",\n \"def make_histogram():\\n\\n # Create a list to save mean angles and mean poss\\n mean_angles = []\\n mean_poss = []\\n\\n # Find the data files (takes all files ending in .txt)\\n filenames = glob.glob(\\\"*.txt\\\")\\n\\n for filename in filenames:\\n\\n # Load the data\\n with open(filename, 'rb') as file:\\n ellipses = pickle.load(file)\\n\\n # Find the range where it levitates\\n # Plot the angle and the major and minor axes of the elipse\\n elFig, (axAx, angAx) = plt.subplots(2, 1, sharex=True)\\n axAx.plot([e[1][0] for e in ellipses])\\n axAx.plot([e[1][1] for e in ellipses])\\n angAx.plot([e[2] for e in ellipses])\\n\\n axAx.set_ylabel(\\\"Axis length (μm)\\\")\\n angAx.set_ylabel(\\\"Angle (°)\\\")\\n angAx.set_xlabel(\\\"Time (s)\\\")\\n\\n axAx.set_title(\\\"Pick one point when the particle starts to levitate\\\\nand one when it stops\\\")\\n\\n points = plt.ginput(2, timeout=-1)\\n plt.close()\\n\\n if not points:\\n continue\\n\\n start_frame = int(points[0][0])\\n end_frame = int(points[1][0])+1\\n\\n # Angles when it levitates are the ones between start and end frame\\n angles = [e[2] for e in ellipses[start_frame:end_frame]]\\n\\n # Convert the 0-180 span of angles to 0-2 pi\\n # This is because it wraps around at 180 rather than 360\\n # so the mean needs to reflect this\\n #breakpoint()\\n rads = np.array(angles) * np.pi / 90\\n\\n mean_rad = circular_mean(rads)\\n\\n mean_angle = 90 * mean_rad / np.pi\\n\\n # Add it to list of mean angles\\n mean_angles.append(mean_angle)\\n\\n # Calculate the mean position\\n positions = np.array([e[0] for e in ellipses[start_frame:end_frame]])\\n\\n mean_pos = np.mean(positions, axis=0)\\n\\n mean_poss.append(mean_pos)\\n\\n\\n # End for filename in filenames\\n\\n # Plot histogram\\n ax = plt.subplot(projection=\\\"polar\\\")\\n\\n rads = np.array(mean_angles) * np.pi / 90\\n bars = ax.hist(rads, bins=72, bottom=0)\\n # Set labels\\n ax.set_thetagrids(tuple(range(0,360,30)), labels=[f\\\"{a}°\\\" for a in range(0, 180, 15)])\\n ax.set_rgrids([0, 1, 2, 3])\\n ax.set_title(\\\"Average angle of semi-major axis of ellipse\\\")\\n\\n\\n fig, posAx = plt.subplots()\\n\\n \\n for p in mean_poss:\\n posAx.plot(*p, 'o')\\n\\n posAx.set_xlabel(r\\\"$x$-position (μm)\\\")\\n posAx.set_ylabel(r\\\"$y$-position (μm)\\\")\\n posAx.set_title(\\\"Average position for the films\\\")\\n plt.show()\",\n \"def problemOne(self):\\n self.hot_volt = self.data['calibration']['hot volt'].tolist()\\n self.pitot_vel = self.data['calibration']['pitot vel'].tolist()\\n # Create interpolation function of FFT data for finding coefficients\\n self.v_hot = np.poly1d(np.array(self.cal_coeffs))\\n # Create string to print coefficients on plot\\n print_coeffs = 'Curve Coefficients:'\\n coeff_index = [4, 3, 2, 1, 0]\\n for i in range(0, 5):\\n print_coeffs += f'\\\\n$a_{i}$ = {self.cal_coeffs[coeff_index[i]]}'\\n # Create curve fit data to plot\\n fit_plot_y = [self.v_hot(j) for j in self.hot_volt]\\n # Calculate difference and standard deviation b/w the interpolation curve and experimental data\\n difference = []\\n for i in self.hot_volt:\\n index = self.hot_volt.index(i)\\n difference.append(self.pitot_vel[index] - self.v_hot(i))\\n std_dev = statistics.stdev(difference)\\n print(f'prob one std dev = {std_dev}')\\n # Plot velocities vs voltage\\n plot_1 = plt.figure(figsize=(8, 8))\\n vv = plot_1.add_subplot(1, 1, 1)\\n props = dict(boxstyle='round', facecolor='white', alpha=0.2)\\n vv.set_xlabel('Hotwire $E_v$ [Volts]', fontsize=14)\\n vv.set_ylabel('Velocity [m/s]', fontsize=14)\\n vv.grid(linewidth=0.5, color='gray', linestyle='--')\\n vv.plot(self.hot_volt, fit_plot_y, color='k', linewidth=1, label='Hotwire Curve Fit')\\n vv.scatter(self.hot_volt, self.pitot_vel, color='r', s=15, label='Pitot Exp. Data', marker='o')\\n vv.text(0.02, 0.9, print_coeffs, transform=vv.transAxes, fontsize=11, verticalalignment='top', bbox=props)\\n vv.legend(loc='upper left')\\n plot_1.savefig(os.path.join(os.getcwd(), r'plots\\\\prob1'))\\n plt.draw()\",\n \"def calibrate(self,(minX,minY,minZ),(maxX,maxY,maxZ),duration = 5,integer = True):\\n\\t\\tt0 = time.time()\\n\\t\\tminXYZ,maxXYZ = [2*31]*3,[-2**31]*3##+- inf...not nice but it will do...\\n\\t\\twhile time.time() - t0 < duration: ## Probably not the best guard\\n\\t\\t\\tself.refresh()\\n\\t\\t\\tpoints = self.coordinateTracker.getListOfCartesianCoordinates()\\n\\t\\t\\tminXYZ = [ min ([minXYZ[i]] + [point[i] for point in points]) for i in [0,1,2] ]\\n\\t\\t\\tmaxXYZ = [ max ([maxXYZ[i]] + [point[i] for point in points]) for i in [0,1,2] ]\\n\\t\\tfactor = max([abs(maxXYZ[i] - minXYZ[i]) for i in [0,1,2]])\\n\\t\\t\\n\\t\\tdef scale((x,y,z)):\\n\\t\\t\\t## Yeah, I know this /could/ be re-factored.\\n\\t\\t\\t## But this is simpler. \\n\\t\\t\\tif factor != 0:\\n\\t\\t\\t\\tx = float(x) - (minXYZ[0]+maxXYZ[0])/2 \\n\\t\\t\\t\\tx = x/factor\\n\\t\\t\\t\\tx = x*abs(maxX - minX)\\n\\t\\t\\t\\tx = x+(maxX + minX)/2\\n\\t\\t\\t\\n\\t\\t\\t\\ty = float(y) - (maxXYZ[1] + minXYZ[1])/2\\n\\t\\t\\t\\ty = y/factor\\n\\t\\t\\t\\ty = y*abs(maxY - minY)\\n\\t\\t\\t\\ty = y+(maxY + minY)/2\\n\\n\\t\\t\\t\\tz = float(z) - (maxXYZ[2]+ minXYZ[2])/2\\n\\t\\t\\t\\tz = z/factor\\n\\t\\t\\t\\tz = z*abs(maxZ - minZ)\\n\\t\\t\\t\\tz = z+(maxZ + minZ)/2\\n\\t\\t\\tif integer: return map(int,(x,y,z))\\n\\t\\t\\telse: return x,y,z\\n\\t\\tself.scale = scale\",\n \"def visualize_save_calibration(performance_sigma, cfg, success):\\n percentiles = PERCENTILES\\n inside_ratio_reference = percentiles[1] - percentiles[0]\\n\\n baseline = confidence_test_values.pop('baseline')\\n sigmas = sorted(confidence_test_values)\\n inside_ratios = [\\n confidence_test_values[sigma]['inside_ratio'] for sigma in sigmas\\n ]\\n confidence = xr.Dataset(\\n data_vars={\\n 'inside_ratio_reference': ((), inside_ratio_reference, {\\n 'units': '1'\\n }),\\n 'inside_ratio': ('sigma', inside_ratios, {\\n 'units': '1'\\n }),\\n 'sigma': ('sigma', sigmas, {\\n 'units': '1'\\n }),\\n })\\n\\n figure, axes = plt.subplots(figsize=(12, 8))\\n axes.plot(sigmas,\\n inside_ratios,\\n color='k',\\n lw=2,\\n label='Perfect models inside the {:.0%} range'.format(\\n inside_ratio_reference),\\n zorder=99)\\n axes.axhline(inside_ratio_reference,\\n color='k',\\n ls='--',\\n label='Reference: {:.0%}'.format(inside_ratio_reference))\\n axes.axhline(baseline['inside_ratio'],\\n color='k',\\n ls=':',\\n label='Unweighted baseline: {:.0%}'.format(\\n baseline['inside_ratio']))\\n\\n if success:\\n axes.axvline(performance_sigma,\\n color='k',\\n ls='-.',\\n label='Selected performance sigma: {:.2f}'.format(\\n performance_sigma))\\n axes.set_title('Performance sigma calibration')\\n else:\\n axes.axvline(\\n performance_sigma,\\n color='gray',\\n ls='-.',\\n label='Best performance sigma: {:.2f} (set manually to use)'.\\n format(performance_sigma))\\n axes.set_title('Performance sigma calibration (FAILED)')\\n\\n # optional: sharpness\\n sharpness = xr.concat([\\n confidence_test_values[sigma]['percentile_spread'].expand_dims(\\n {'sigma': [sigma]}) for sigma in sigmas], dim='sigma')\\n sharpness /= baseline['percentile_spread']\\n axes.plot(sigmas,\\n sharpness.mean('perfect_model_ensemble'),\\n color='lightgray',\\n label='Spread relative to unweighted (mean & 80% range)')\\n axes.fill_between(sigmas,\\n *sharpness.quantile((.1, .9), 'perfect_model_ensemble'),\\n facecolor='lightgray',\\n edgecolor='none',\\n alpha=.3)\\n axes.axhline(1, color='lightgray', ls='--')\\n\\n sharpness.attrs['units'] = '1'\\n confidence['sharpness'] = sharpness\\n\\n axes.set_xlim(SIGMA_RANGE)\\n axes.set_ylim(0, 1.3)\\n axes.set_xlabel('sigma (1)')\\n axes.set_ylabel('Ratio (1)')\\n\\n axes.legend()\\n\\n filename_plot = get_plot_filename('performance_sigma_calibration', cfg)\\n figure.savefig(filename_plot, dpi=300, bbox_inches='tight')\\n plt.close(figure)\\n\\n filename_data = get_diagnostic_filename('performance_sigma_calibration',\\n cfg,\\n extension='nc')\\n confidence.to_netcdf(filename_data)\",\n \"def get_avg_points(self):\\n pass\",\n \"def gavg(idata):\\n\\t\\n\\twgt1=np.cos(np.deg2rad(idata.lat))*(idata*0+1)\\n\\tga=(wgt1*idata).sum(dim=['lat','lon'])/wgt1.sum(dim=['lat','lon'])\\n\\n\\treturn ga\",\n \"def ratio(gb_data, data_depcode, data_ratio_hospitalises,current_date, data_hospitalises, current_date_file, min_value_80p , nbhospitalises_80p) :\\n start = time.time()\\n fig, ax = plt.subplots(figsize=(12, 8))\\n\\n plt.title(f\\\"Ratio of in-hospital deaths to hospitalizations : {current_date}\\\", fontsize=20)\\n plt.ylabel(\\\"Total number of deceases / Total number of hospitalized\\\")\\n plt.xlabel(\\\"Total number of hospitalized\\\")\\n\\n for i, txt in enumerate(data_depcode):\\n if (data_hospitalises[i] > data_hospitalises.max() * 0.20):\\n ax.annotate(txt, (data_hospitalises[i], data_ratio_hospitalises[i]), xytext=(data_hospitalises[i] + 20, data_ratio_hospitalises[i])) \\n\\n plt.axhline(data_ratio_hospitalises.mean(), color='green', linestyle='--', label=f'average death ratio ({data_ratio_hospitalises.mean():.2f}%)')\\n\\n plt.axvline(min_value_80p, color='pink', linestyle='-', label=f\\\"80% of the number of hospitalized people in France are on the right side of the line ({nbhospitalises_80p:.0f} hospitalized)\\\")\\n\\n ax.scatter(data_hospitalises, data_ratio_hospitalises)\\n\\n ax.annotate('updated chart',xy=(1, 0), xytext=(-15, 10), fontsize=15,\\n xycoords='axes fraction', textcoords = 'offset points',\\n bbox=dict(facecolor = 'white', alpha = 0.9),\\n horizontalalignment = 'right', verticalalignment = 'bottom')\\n\\n ax.yaxis.set_major_formatter(mtick.FormatStrFormatter('%.0f%%'))\\n plt.legend()\\n\\n current_date_file = gb_data['date'].max().strftime('%Y%m%d')\\n end = time.time()\\n print(\\\"Time spent on ratio plot: {0:.5f} s.\\\".format(end - start)) \\n plt.show()\",\n \"def plot_average_SA(repetitions, runs):\\n\\n\\ttotalscores = []\\n\\n\\t# for each repetition\\n\\tfor i in range(repetitions):\\n\\n\\t\\t# create empty list\\n\\t\\talgorithm_scores = []\\n\\n\\t\\t# create random schedule and perform simulated annealing with geman coolingscheme\\n\\t\\tchambers, allcourses, student_list, schedule = create_schedule()\\n\\n\\t\\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, scores = simulated_annealing(geman, runs, chambers, allcourses, student_list, schedule)\\n\\n\\t\\t# create random schedule and perform simulated annealing with linear coolingscheme\\n\\t\\tchambers, allcourses, student_list, schedule = create_schedule()\\n\\t\\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, linear_scores = simulated_annealing(linear, runs, chambers, allcourses, student_list, schedule)\\n\\n\\t\\t# create random schedule and perform simulated annealing with sigmoidal coolingscheme\\n\\t\\tchambers, allcourses, student_list, schedule = create_schedule()\\n\\t\\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, sigmoidal_scores = simulated_annealing(sigmoidal, runs, chambers, allcourses, student_list, schedule)\\n\\n\\t\\t# create random schedule and perform simulated annealing with exponential coolingscheme\\n\\t\\tchambers, allcourses, student_list, schedule = create_schedule()\\n\\t\\tbest_schedule, best_score, best_courses, best_student_list, best_chambers, exponential_scores = simulated_annealing(exponential, runs, chambers, allcourses, student_list, schedule)\\n\\n\\t\\t# add scores to alogrithm list\\n\\t\\talgorithm_scores.append([geman_scores, linear_scores, sigmoidal_scores, exponential_scores])\\n\\n\\t\\t# add algorithm list to totalscore\\n\\t\\ttotalscores.append(algorithm_scores)\\n\\n\\t# create empty lists for score per coolingscheme\\n\\tall_geman_scores = []\\n\\tall_linear_scores = []\\n\\tall_sigmoidal_scores = []\\n\\tall_exponential_scores = []\\n\\n\\t# add single scores coolingschem into lists with all scores\\n\\tfor i in range(repetitions):\\n\\t\\tall_geman_scores.append(totalscores[i][0][0])\\n\\t\\tall_linear_scores.append(totalscores[i][0][1])\\n\\t\\tall_sigmoidal_scores.append(totalscores[i][0][2])\\n\\t\\tall_exponential_scores.append(totalscores[i][0][3])\\n\\n\\t# create empty lists for sorted scores\\n\\tgeman_sorted_scores = []\\n\\tlinear_sorted_scores = []\\n\\tsigmoidal_sorted_scores = []\\n\\texponential_sorted_scores = []\\n\\n\\t# for each run\\n\\tfor i in range(runs):\\n\\n\\t\\t# create empty lists for selected scores\\n\\t\\tgeman_selected_score = []\\n\\t\\tlinear_selected_score = []\\n\\t\\tsigmoidal_selected_score = []\\n\\t\\texponential_selected_score = []\\n\\n\\t\\t# for each repetition\\n\\t\\tfor j in range(repetitions):\\n\\n\\t\\t\\t# add selected score to all score list of coolingscheme\\n\\t\\t\\tgeman_selected_score.append(all_geman_scores[j][i])\\n\\t\\t\\tlinear_selected_score.append(all_linear_scores[j][i])\\n\\t\\t\\tsigmoidal_selected_score.append(all_sigmoidal_scores[j][i])\\n\\t\\t\\texponential_selected_score.append(all_exponential_scores[j][i])\\n\\n\\t\\t# add selected scores into sorted score\\n\\t\\tgeman_sorted_scores.append(geman_selected_score)\\n\\t\\tlinear_sorted_scores.append(linear_selected_score)\\n\\t\\tsigmoidal_sorted_scores.append(sigmoidal_selected_score)\\n\\t\\texponential_sorted_scores.append(exponential_selected_score)\\n\\n\\t# calculate average for each sorted scores\\n\\tgeman_average_scores = []\\n\\tfor scores in geman_sorted_scores:\\n\\t\\tgeman_average_scores.append(sum(scores)/len(scores))\\n\\n\\tlinear_average_scores = []\\n\\tfor scores in linear_sorted_scores:\\n\\t\\tlinear_average_scores.append(sum(scores)/len(scores))\\n\\n\\tsigmoidal_average_scores = []\\n\\tfor scores in sigmoidal_sorted_scores:\\n\\t\\tsigmoidal_average_scores.append(sum(scores)/len(scores))\\n\\n\\texponential_average_scores = []\\n\\tfor scores in exponential_sorted_scores:\\n\\t\\texponential_average_scores.append(sum(scores)/len(scores))\\n\\n\\t# store average scores in one list\\n\\taverage_scores = [geman_average_scores, linear_average_scores, sigmoidal_average_scores, exponential_average_scores]\\n\\n\\t# create plot with multiple lines of all coolingschemes\\n\\tmultiple_simulated_annealing(average_scores)\",\n \"def calc_stat_values(self):\",\n \"def calc_perc_reducts():\\n #Load RCP2.6 datq\\n cubes = iris.load(data_dir+'DMSSO2NH3_18502100_RCP26_monthly.nc')\\n #Get the surface and high level SO2 emissions\\n surf_cube = cubes[3][:,0]\\n high_cube = cubes[1][:,0]\\n cubes = iris.cube.CubeList([surf_cube,high_cube])\\n\\n for i in range(0,len(cubes)):\\n #Add the year and month to the cube and extract for 2009 onwards\\n iris.coord_categorisation.add_year(cubes[i],'time',name='year')\\n iris.coord_categorisation.add_month(cubes[i],'time',name='month')\\n cubes[i] = cubes[i].extract(iris.Constraint(year = lambda y: y >=2009))\\n\\n #Make the year-on-year reduction rates\\n yoy_rates = []\\n for cube in cubes:\\n #Calculate the global mean timeseries\\n cube.coord('latitude').guess_bounds()\\n cube.coord('longitude').guess_bounds()\\n area_weights = iris.analysis.cartography.area_weights(cube)\\n cube_mean = cube.collapsed(['latitude','longitude'],iris.analysis.MEAN,weights=area_weights)\\n\\n cube_rates = np.ones((cube_mean.shape))\\n #Loop over the months and calculate the changes from the previous year\\n #Calculate the year on year proportional changes in the global mean\\n for i in range(12,cube_mean.shape[0]):\\n cube_rates[i] = cube_mean[i].data / cube_mean[(i-12)].data\\n\\n yoy_rates.append(cube_rates)\\n\\n return yoy_rates\",\n \"def compute(self, Rs, D):\\n self.Rs = Rs\\n self.D = D\\n self.M = (self.Rs * c**2 * au) / (2 * G * M_sun)\\n print(\\\"M = %.1e M☉\\\\t%.2e Kg\\\" % (self.M, self.M*M_sun))\\n print(\\\"Rs = %s ua\\\\t%.2e m\\\" % (self.Rs, self.Rs*au))\\n print(\\\"D = %s ua\\\\t%.2e m\\\\n\\\" % (self.D, self.D*au))\\n\\n vrai_debut = time.process_time()\\n\\n\\n seen_angle, deviated_angle = self.trajectories()\\n\\n self.interpolation = self.interpolate(seen_angle, deviated_angle)\\n\\n if self.display_interpolation is True:\\n xmin = np.min(seen_angle)\\n xmax = np.max(seen_angle)\\n seen_angle_splin = np.linspace(xmin, xmax, 20001)\\n deviated_angle_splin = self.interpolation(seen_angle_splin)\\n plt.figure('Trajectories interpolation')\\n plt.clf()\\n plt.title(\\\"Light deviation interpolation\\\", va='bottom')\\n plt.xlabel('seen angle(°)')\\n plt.ylabel('deviated angle(°)')\\n plt.plot(seen_angle, deviated_angle, 'o')\\n plt.plot(seen_angle_splin, deviated_angle_splin)\\n plt.grid()\\n #plt.savefig('interpolation.png', dpi=250, bbox_inches='tight')\\n plt.draw()\\n#\\n print(\\\"last angle\\\", seen_angle[-1])\\n print(\\\"trajectories time: %.1f\\\" % (time.process_time()-vrai_debut))\\n\\n img_matrix_x, img_matrix_y = self.create_matrices()\\n\\n self.img_matrix_x = img_matrix_x\\n self.img_matrix_y = img_matrix_y\\n\\n self.img2 = self.img_pixels(self.img_debut)\\n\\n vrai_fin = time.process_time()\\n print(\\\"\\\\nglobal computing time: %.1f\\\\n\\\" % (vrai_fin-vrai_debut))\",\n \"def average_energy(power,events,borders,eventName):\\n event_consider = events[events['eventName']==eventName].reset_index(drop=True)\\n average = 0\\n i = 0\\n count = 0\\n minValue = 10000\\n maxValue = 0\\n minAverage = 10000\\n maxAverage = 0 \\n while(i<len(event_consider)):\\n date = time.mktime(datetime.strptime(event_consider['time'][i], \\\"%Y-%m-%d %H:%M:%S\\\").timetuple())\\n start = str(datetime.fromtimestamp(date+borders[0]))\\n end = str(datetime.fromtimestamp(date+borders[1]))\\n values = power[(power['time']>=start)&(power['time']<=end)]['value']\\n sum_values = sum(values)\\n tot_values = len(values)\\n if tot_values>0:\\n if values.max() > maxValue:\\n maxValue = values.max()\\n if values.min() < minValue:\\n minValue = values.min()\\n if sum_values/tot_values > maxAverage:\\n maxAverage = sum_values/tot_values\\n if sum_values/tot_values < minAverage:\\n minAverage = sum_values/tot_values\\n average = average + sum_values/tot_values\\n count += 1\\n i += 1\\n if count>0:\\n average = average / count\\n print(\\\"number of\\\", eventName ,\\\"in groudtruth and power=\\\",count)\\n print(\\\"minValue=\\\",minValue,\\\"maxValue=\\\",maxValue)\\n print(\\\"minAverage=\\\",minAverage,\\\"maxAverage=\\\",maxAverage)\\n print(\\\"Final Av=\\\",average)\\n return average\\n else:\\n print(\\\"Not values found in the range\\\")\",\n \"def avgtr(self):\\n return np.diff(self.trtimes).mean()\",\n \"def calibration(self) -> tuple[int, int, int, int, int]:\",\n \"def PMTandPiezoPlot(datadir,run,event,gain): \\n en = event\\n mu = gain\\n e = sbc.DataHandling.GetSBCEvent.GetEvent(datadir+'/'+run,en)\\n print(e[\\\"fastDAQ\\\"].keys())\\n cgate = e[\\\"fastDAQ\\\"][\\\"CAMgate\\\"]\\n dcam = np.diff(cgate)\\n \\n p0=e[\\\"fastDAQ\\\"][\\\"Piezo1\\\"]\\n p1 = e[\\\"fastDAQ\\\"][\\\"Piezo2\\\"]\\n fdt = e[\\\"fastDAQ\\\"][\\\"time\\\"]\\n runreconpath = \\\"/pnfs/coupp/persistent/grid_output/SBC-17/output/%s/\\\"%run\\n pmtdiffs = []\\n diffs = []\\n \\n camOnTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] < -0.5]\\n camOffTimes = [fdt[i] for i in range(len(dcam)) if dcam[i] > 0.5]\\n print(len(camOnTimes))\\n print(len(camOffTimes))\\n \\n acousticfilename = runreconpath+\\\"AcousticAnalysis_%s.bin\\\"%run\\n a = sbc.DataHandling.ReadBinary.ReadBlock(acousticfilename)\\n bubt0 = a[\\\"bubble_t0\\\"]\\n \\n pmttracetime = e[\\\"PMTtraces\\\"][\\\"t0_sec\\\"][:,0]+e[\\\"PMTtraces\\\"][\\\"t0_frac\\\"][:,0]\\n d=sbc.AnalysisModules.PMTfastDAQalignment.PMTandFastDAQalignment(e)\\n pmtalign = d[\\\"PMT_trigt0_sec\\\"]+d[\\\"PMT_trigt0_frac\\\"]\\n tracetimes = pmttracetime - pmtalign\\n at0 = bubt0[en,0]\\n at0_1 = bubt0[en,1]\\n \\n allxyzfname = \\\"/pnfs/coupp/persistent/grid_output/SBC-17/output/SimpleXYZ_all.bin\\\"\\n xyzf = sbc.DataHandling.ReadBinary.ReadBlock(allxyzfname)\\n indices = [i for i,x in enumerate(xyzf[\\\"runid\\\"]) if str(x[0])+\\\"_\\\"+str(x[1]) == run]\\n xyz_reconstructed = True\\n if len(indices) > 0:\\n runposreco = {\\\"ev\\\":[xyzf[\\\"ev\\\"][indices]],\\\"x\\\":[xyzf[\\\"bubX\\\"][indices]],\\n \\\"y\\\":[xyzf[\\\"bubY\\\"][indices]],\\\"z\\\":[xyzf[\\\"bubZ\\\"][indices]]}\\n z = runposreco[\\\"z\\\"][0][int(int(en))]\\n else:\\n print(\\\"no handscan?\\\")\\n z = 1.5\\n xyz_reconstructed = False\\n lag_expected = (-23.387649*z - 261.020495)*1e-6 # fit from other analysis\\n t0_expected_p0 = at0 + lag_expected\\n t0_expected_p1 = at0_1 + lag_expected\\n \\n i=0\\n candidates = []\\n candidate_times=[]\\n for t in (tracetimes-at0):\\n \\n if t<0.2 and t>-0.2:\\n lastCamOff = 0\\n for k in range(len(camOffTimes)):\\n if t+at0 > camOffTimes[k]:\\n lastCamOff = camOffTimes[k]\\n elif t+at0 < camOffTimes[k]:\\n break\\n if t+at0-lastCamOff > 25e-6:\\n \\n pmtdiffs.append(t)\\n trace = np.fabs(e[\\\"PMTtraces\\\"][\\\"traces\\\"][i][0])\\n if max(trace) == 128:\\n trace = pi.stitchTraces(trace,np.fabs(e[\\\"PMTtraces\\\"][\\\"traces\\\"][i][1]))\\n dt = e[\\\"PMTtraces\\\"][\\\"dt\\\"][i][0]\\n #baseline = np.mean(trace[0:50])\\n #trace = trace - baseline\\n [phe,n,totInt,pktimes] = pi.SBC_pulse_integrator_bressler(trace,dt)\\n \\n if phe != None:\\n phe /= mu\\n candidates.append(phe)\\n candidate_times.append(t)\\n i+=1\\n candidate_phe = 0\\n the_index = 0\\n i=0\\n near_trace_indices = []\\n for t in candidate_times:\\n if t > -500e-6 and t <0:\\n near_trace_indices.append(list(tracetimes-at0).index(t))\\n if candidates[i]>candidate_phe:\\n candidate_phe = candidates[i]\\n the_index = i\\n i+=1\\n \\n if len(candidates) != 0:\\n if max(candidates)>0:\\n diffs.append(candidate_times[candidates.index(max(candidates))])\\n fig,ax1 = plt.subplots()\\n ax2 = ax1.twinx()\\n ax1.plot(fdt,p0,'b',alpha=0.6, label = 'piezo 0')\\n ax1.plot(fdt,p1,'k',alpha=0.2, label= 'piezo 1')\\n for i in range(len(candidates)):\\n if i == the_index:\\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'r',lw=4)\\n else:\\n ax2.plot([candidate_times[i]+at0,candidate_times[i]+at0],[0,candidates[i]],'y',lw=4)\\n #ax2.plot([min(candidate_times),max(candidate_times)],[0,0],linewidth=2)\\n ax1.plot([at0,at0],[-0.5,0.5],'b',linewidth=2, label = 'acoustic t0, p0')\\n ax1.plot([at0_1,at0_1],[-0.5,0.5],'k',linewidth=2, label = 'acoustic t0, p1')\\n \\\"\\\"\\\"\\n if xyz_reconstructed:\\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0')\\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1')\\n else:\\n ax1.plot([t0_expected_p0,t0_expected_p0],[-0.5,0.5],'b:',linewidth=2, label = 'expected PMT t0, p0, center of chamber')\\n ax1.plot([t0_expected_p1,t0_expected_p1],[-0.5,0.5],'k:',linewidth=2, label = 'expected PMT t0, p1, center of chamber')\\n \\\"\\\"\\\"\\n ax1.plot(fdt,cgate,'c')\\n ax1.plot(fdt[:-1],dcam,'m')\\n ax2.set_ylabel('pmt signal (phe)',fontsize=20)\\n ax1.set_xlabel('time (s)',fontsize=20)\\n ax1.set_ylabel('Acoustic signa(V)',fontsize=20)\\n ax1.set_ylim([min(p1),max(p1)])\\n ax2.set_xlim([-0.1,0.1])\\n #ax2.set_ylim([0,5])\\n ax1.legend()\\n plt.show\\n \\n for j in near_trace_indices:\\n trace = e[\\\"PMTtraces\\\"][\\\"traces\\\"][j][0]\\n dt = e[\\\"PMTtraces\\\"][\\\"dt\\\"]\\n dt_tr = dt[j][0]\\n tPMT = np.arange(len(trace))*dt_tr\\n plt.figure()\\n plt.plot(tPMT,trace)\\n plt.xlabel(\\\"t (s)\\\")\\n plt.ylabel(\\\"PMT signal\\\")\\n plt.show\\n \\n plt.figure()\\n plt.plot(e[\\\"fastDAQ\\\"][\\\"time\\\"],e[\\\"fastDAQ\\\"][\\\"VetoCoinc\\\"])\\n plt.ylabel(\\\"Veto Coincidence signal\\\",fontsize=18)\\n plt.xlabel(\\\"time (s)\\\")\\n plt.show\",\n \"def run():\\n\\n Number_repetitions = 1\\n Rate = np.zeros((Number_repetitions,1))\\n Rate20 = np.zeros((Number_repetitions,1))\\n Penalty20 = np.zeros((Number_repetitions, 1))\\n\\n # Loop to average\\n for idx in np.arange(0,Number_repetitions,1):\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n a = e.create_agent(LearningAgent) # create agent\\n e.set_primary_agent(a, enforce_deadline=True) # specify agent to track\\n # NOTE: You can set enforce_deadline=False while debugging to allow longer trials\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0000001, display=True) # create simulator (uses pygame when display=True, if available)\\n # NOTE: To speed up simulation, reduce update_delay and/or set display=False\\n\\n sim.run(n_trials=100) # run for a specified number of trials\\n # NOTE: To quit midway, press Esc or close pygame window, or hit Ctrl+C on the command-line\\n\\n # I've edited the enviroment variable to do the plot creating an completions array\\n completions = np.array(e.completions)\\n rate = float(completions.sum())/float((len(completions)))\\n rate20 = float(completions[-20:].sum())/20\\n\\n Rate[idx] = rate\\n Rate20[idx] = rate20\\n\\n Wrong = np.array(a.wrong_moves_per_run[-20:]).mean()\\n Penalty20[idx] = Wrong\\n\\n plt.scatter(np.arange(0,len(completions)),completions)\\n plt.plot(Wrong)\\n plt.xlabel('Trial')\\n plt.ylabel('1 = Get in the destination, 0 = did not get')\\n plt.title('Reiforcement learning progress')\\n plt.legend(['Rate of completion: ' + str(rate) + '. Rate last 20: ' + str(rate20) + '.Mean penalty last 20: ' + str(Wrong)])\\n plt.show()\\n\\n #print 'Accuracy: ' + str(Rate) + '. Mean: ' + str(np.mean(Rate))\\n #print 'Mean 20: ' + str(np.mean(Rate20))#'Accuracy 20: ' + str(Rate20) + '. Mean 20: ' + str(np.mean(Rate20))\\n #print 'Mean_penalty: ' + str(np.mean(Penalty20))\\n\\n # Print state table with actions\\n #t = 0\\n #for state in a.states:\\n #print 'State ' + str(state) + '. Best action: ' + str((str(np.argmax(a.QTable[t][:]))))\\n #t += 1\",\n \"def estimate_arpu(x):\\n arpu = 0\\n if x['mean_luminosity_km2'] > 5:\\n # #10 year time horizon\\n # for i in range(0, 10):\\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\\n # arpu += (\\n # (20*12) / (1 + 0.03) ** i\\n # )\\n return 20 * 12 * 10#arpu\\n elif x['mean_luminosity_km2'] > 1:\\n # for i in range(0, 10):\\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\\n # arpu += (\\n # (5*12) / (1 + 0.03) ** i\\n # )\\n return 5 * 12 * 10#arpu\\n else:\\n # for i in range(0, 10):\\n # #discounted_arpu = (arpu*months) / (1 + discount_rate) ** year\\n # arpu += (\\n # (2*12) / (1 + 0.03) ** i\\n # )\\n return 2 * 12 * 10#arpu\",\n \"def dishlist_avg_cal(n:list)->float:\\r\\n all_cal = dishlist_cal(n)\\r\\n return sum(all_cal)/len(all_cal)\",\n \"def calculate_average_run_accuracy(self):\\n overall_true_rate, true_positive_rate, true_negative_rate, false_positive_rate, false_negative_rate, true_positive_rate_cutoff, true_negative_rate_cutoff, \\\\\\n false_positive_rate_cutoff, false_negative_rate_cutoff, unclassified_cutoff, matthews_correlation_coefficient, brier_score, auc_score, fit_time, hmeasure = [0] * 15\\n balanced_accuracy_arr = []\\n auc_arr = []\\n hmeasure_arr = []\\n brier_score_arr = []\\n fit_time_arr = []\\n mcc_arr = []\\n true_positive_arr = []\\n true_negative_arr = []\\n false_positive_arr = []\\n false_negative_arr = []\\n\\n count = 0\\n for result_dictionary in self.errors:\\n for z in range(len(result_dictionary[\\\"balanced_accuracy_arr\\\"])):\\n overall_true_rate += result_dictionary[\\\"balanced_accuracy_arr\\\"][z]\\n true_positive_rate += result_dictionary[\\\"true_positive_rate_arr\\\"][z]\\n true_negative_rate += result_dictionary[\\\"true_negative_rate_arr\\\"][z]\\n false_positive_rate += result_dictionary[\\\"false_positive_rate_arr\\\"][z]\\n false_negative_rate += result_dictionary[\\\"false_negative_rate_arr\\\"][z]\\n matthews_correlation_coefficient += result_dictionary[\\\"mcc_arr\\\"][z]\\n auc_score += result_dictionary[\\\"auc_arr\\\"][z]\\n brier_score += result_dictionary[\\\"brier_score_arr\\\"][z]\\n fit_time += result_dictionary[\\\"fit_time_arr\\\"][z]\\n hmeasure += result_dictionary[\\\"hmeasure_arr\\\"][z]\\n count += 1\\n\\n true_positive_rate_cutoff += result_dictionary[\\\"avg_true_positive_rate_with_prob_cutoff\\\"]\\n true_negative_rate_cutoff += result_dictionary[\\\"avg_true_negative_rate_with_prob_cutoff\\\"]\\n false_positive_rate_cutoff += result_dictionary[\\\"avg_false_positive_rate_with_prob_cutoff\\\"]\\n false_negative_rate_cutoff += result_dictionary[\\\"avg_false_negative_rate_with_prob_cutoff\\\"]\\n unclassified_cutoff += result_dictionary[\\\"avg_false_negative_rate_with_prob_cutoff\\\"]\\n balanced_accuracy_arr += result_dictionary[\\\"balanced_accuracy_arr\\\"]\\n hmeasure_arr += result_dictionary[\\\"hmeasure_arr\\\"]\\n auc_arr += result_dictionary[\\\"auc_arr\\\"]\\n brier_score_arr += result_dictionary[\\\"brier_score_arr\\\"]\\n fit_time_arr += result_dictionary[\\\"fit_time_arr\\\"]\\n mcc_arr += result_dictionary[\\\"mcc_arr\\\"]\\n true_positive_arr += result_dictionary[\\\"true_positive_rate_arr\\\"]\\n true_negative_arr += result_dictionary[\\\"true_negative_rate_arr\\\"]\\n false_positive_arr += result_dictionary[\\\"false_positive_rate_arr\\\"]\\n false_negative_arr += result_dictionary[\\\"false_negative_rate_arr\\\"]\\n\\n avg_run_results = [None] * 31\\n avg_run_results[0] = matthews_correlation_coefficient / float(count)\\n avg_run_results[1] = brier_score / float(count)\\n avg_run_results[2] = overall_true_rate / float(count)\\n avg_run_results[3] = true_positive_rate / float(count)\\n avg_run_results[4] = true_negative_rate / float(count)\\n avg_run_results[5] = false_positive_rate / float(count)\\n avg_run_results[6] = false_negative_rate / float(count)\\n avg_run_results[7] = true_positive_rate_cutoff / float(len(self.errors))\\n avg_run_results[8] = true_negative_rate_cutoff / float(len(self.errors))\\n avg_run_results[9] = false_positive_rate_cutoff / float(len(self.errors))\\n avg_run_results[10] = false_negative_rate_cutoff / float(len(self.errors))\\n avg_run_results[11] = unclassified_cutoff / float(len(self.errors))\\n avg_run_results[12] = fit_time / float(count)\\n avg_run_results[14] = balanced_accuracy_arr\\n avg_run_results[15] = auc_score / float(count)\\n avg_run_results[16] = auc_arr\\n avg_run_results[17] = brier_score_arr\\n avg_run_results[18] = fit_time_arr\\n avg_run_results[19] = mcc_arr\\n avg_run_results[13] = self.calculate_std_deviation(balanced_accuracy_arr)\\n avg_run_results[20] = self.calculate_std_deviation(mcc_arr)\\n avg_run_results[21] = self.calculate_std_deviation(brier_score_arr)\\n avg_run_results[22] = self.calculate_std_deviation(auc_arr)\\n avg_run_results[23] = self.calculate_std_deviation(fit_time_arr)\\n avg_run_results[24] = self.calculate_std_deviation(true_positive_arr)\\n avg_run_results[25] = self.calculate_std_deviation(true_negative_arr)\\n avg_run_results[26] = self.calculate_std_deviation(false_positive_arr)\\n avg_run_results[27] = self.calculate_std_deviation(false_negative_arr)\\n avg_run_results[28] = hmeasure / float(count)\\n avg_run_results[29] = self.calculate_std_deviation(hmeasure_arr)\\n avg_run_results[30] = hmeasure_arr\\n\\n return avg_run_results\",\n \"def AllFreAverageV(self,):\\n \\t\\tv_array = self.data\\n \\t\\taaverage_v = np.average(v_array[:,1])\\n \\t\\tprint('Whole frequency average group velocity:\\\\nVw=',aaverage_v/1000,'km/s')\\n \\t\\treturn\",\n \"def trysavgol(window, order, data, xaxis):\\r\\n for datum in data:\\r\\n filt = scipy.signal.savgol_filter(datum,window,order)\\r\\n f = makeplot(xaxis, [datum, filt],[\\\"data\\\",\\\"filter\\\"], \\\"Temperature / $[J/k_B]$\\\",\\\\\\r\\n \\\"Heat Capacity / $[k_B]$\\\", plainlines = True)\\r\\n f.show()\\r\\n f.savefig(\\\"savgol.svg\\\")\\r\\n Tc = np.mean(xaxis[filt == max(filt)])\\r\\n print(\\\"The predicted value of Tc is: \\\"+str(Tc))\",\n \"def print_avg():\",\n \"def extract_avg_charge_time_5(batch,index):\\n avg_time = []\\n for ind in index:\\n cell_no = list(batch.keys())[ind]\\n avg_time_ = np.average(batch[cell_no]['summary']['chargetime'][1:6]) #Cycle 2 to cycle 6\\n # avg_time.append(avg_time_)\\n avg_time.append(log(abs(avg_time_),10))\\n avg_time = np.reshape(avg_time,(-1,1))\\n return avg_time\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63869935","0.6185194","0.6163579","0.60991865","0.5894125","0.5810871","0.57928896","0.5788251","0.5757029","0.5747513","0.5740013","0.567313","0.56440735","0.56413454","0.56288755","0.5609218","0.56066924","0.5535295","0.550225","0.5496323","0.5492045","0.5489493","0.5485421","0.54543865","0.54501426","0.5447128","0.5420978","0.54183143","0.5415472","0.54060495","0.54057413","0.5405083","0.53769195","0.53755724","0.536091","0.53543574","0.53543574","0.53543574","0.53484005","0.5341372","0.5332465","0.53279877","0.532441","0.53241915","0.5317844","0.5313415","0.5301502","0.52915716","0.528853","0.52796936","0.5278372","0.52773255","0.52691114","0.52684605","0.525682","0.5249801","0.52478087","0.52385974","0.523205","0.52309346","0.52280855","0.522659","0.5223225","0.52192277","0.52104884","0.5205377","0.5205304","0.5204282","0.52037644","0.52036244","0.5202539","0.51961976","0.51932263","0.519095","0.5190006","0.5187888","0.51812583","0.5176979","0.5171147","0.5167627","0.5165616","0.51646864","0.5158595","0.51508737","0.51456803","0.51322484","0.51315194","0.51218855","0.51192695","0.5115879","0.5115324","0.51105696","0.51074195","0.5106569","0.51059985","0.5098528","0.50902534","0.5088383","0.5086828","0.5085778"],"string":"[\n \"0.63869935\",\n \"0.6185194\",\n \"0.6163579\",\n \"0.60991865\",\n \"0.5894125\",\n \"0.5810871\",\n \"0.57928896\",\n \"0.5788251\",\n \"0.5757029\",\n \"0.5747513\",\n \"0.5740013\",\n \"0.567313\",\n \"0.56440735\",\n \"0.56413454\",\n \"0.56288755\",\n \"0.5609218\",\n \"0.56066924\",\n \"0.5535295\",\n \"0.550225\",\n \"0.5496323\",\n \"0.5492045\",\n \"0.5489493\",\n \"0.5485421\",\n \"0.54543865\",\n \"0.54501426\",\n \"0.5447128\",\n \"0.5420978\",\n \"0.54183143\",\n \"0.5415472\",\n \"0.54060495\",\n \"0.54057413\",\n \"0.5405083\",\n \"0.53769195\",\n \"0.53755724\",\n \"0.536091\",\n \"0.53543574\",\n \"0.53543574\",\n \"0.53543574\",\n \"0.53484005\",\n \"0.5341372\",\n \"0.5332465\",\n \"0.53279877\",\n \"0.532441\",\n \"0.53241915\",\n \"0.5317844\",\n \"0.5313415\",\n \"0.5301502\",\n \"0.52915716\",\n \"0.528853\",\n \"0.52796936\",\n \"0.5278372\",\n \"0.52773255\",\n \"0.52691114\",\n \"0.52684605\",\n \"0.525682\",\n \"0.5249801\",\n \"0.52478087\",\n \"0.52385974\",\n \"0.523205\",\n \"0.52309346\",\n \"0.52280855\",\n \"0.522659\",\n \"0.5223225\",\n \"0.52192277\",\n \"0.52104884\",\n \"0.5205377\",\n \"0.5205304\",\n \"0.5204282\",\n \"0.52037644\",\n \"0.52036244\",\n \"0.5202539\",\n \"0.51961976\",\n \"0.51932263\",\n \"0.519095\",\n \"0.5190006\",\n \"0.5187888\",\n \"0.51812583\",\n \"0.5176979\",\n \"0.5171147\",\n \"0.5167627\",\n \"0.5165616\",\n \"0.51646864\",\n \"0.5158595\",\n \"0.51508737\",\n \"0.51456803\",\n \"0.51322484\",\n \"0.51315194\",\n \"0.51218855\",\n \"0.51192695\",\n \"0.5115879\",\n \"0.5115324\",\n \"0.51105696\",\n \"0.51074195\",\n \"0.5106569\",\n \"0.51059985\",\n \"0.5098528\",\n \"0.50902534\",\n \"0.5088383\",\n \"0.5086828\",\n \"0.5085778\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.51465684"},"document_rank":{"kind":"string","value":"84"}}},{"rowIdx":23197,"cells":{"query":{"kind":"string","value":"Retrieve the .mat filenames for the troika dataset. Review the README in ./datasets/troika/ to understand the organization of the .mat files."},"document":{"kind":"string","value":"def LoadTroikaDataset():\n data_dir = \"./datasets/troika/training_data\"\n data_fls = sorted(glob.glob(data_dir + \"/DATA_*.mat\"))\n ref_fls = sorted(glob.glob(data_dir + \"/REF_*.mat\"))\n return data_fls, ref_fls"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def matrices_names(self, folder=None):\n if folder is None:\n abs_path = os.path.abspath(os.path.dirname(sys.argv[0]))\n folder = os.path.join(abs_path, 'matrix')\n\n matrix_name_x = \"%s_%s_%s_%s_x.txt\" % (\n self.D, self.Rs, self.axe_X, self.FOV_img)\n matrix_file_x = os.path.join(folder, matrix_name_x)\n\n matrix_name_y = \"%s_%s_%s_%s_y.txt\" % (\n self.D, self.Rs, self.axe_X, self.FOV_img)\n matrix_file_y = os.path.join(folder, matrix_name_y)\n\n return matrix_file_x, matrix_file_y","def _get_subject_files(self):\n from itertools import chain\n\n subjsf = fetch_one_file(self.ica_dir, self._subjects_fname)\n mat_file = sio.loadmat(subjsf)['files']\n return [f.strip() for f in list(chain.from_iterable(chain.from_iterable(chain.from_iterable(mat_file))))]","def collect_mat_files(dpath,dname='LMD',didx=0):\n #dnames = ['LMD','Ballroom']\n #dname = dnames[didx]\n return glob.glob(os.path.join(dpath, dname,'*.mat'))","def get_feature_labels_files(dataset):\n features = []\n audio_labels = []\n focal_labels = []\n files = []\n for frame in dataset:\n files.append(frame[0])\n features.append(frame[1][0].T)\n if frame[1][1] is not None:\n audio_labels.append(frame[1][1][0].T)\n focal_labels.append(frame[1][1][1].T)\n else:\n audio_labels.append(None)\n focal_labels.append(None)\n features = np.expand_dims(np.asarray(features), 4)\n audio_labels = np.asarray(audio_labels)\n focal_labels = np.asarray(focal_labels)\n return [features, audio_labels,focal_labels, files]","def read_matricies():\n\tmatrix_arr = []\n\tcurr_dirpath = os.getcwd()\n\tfor subdir, dirs, files in os.walk(curr_dirpath + '/Example Matrices'):\n\t\tfor curr_file in files:\n\t\t\tcurr_filepath = curr_dirpath + '/Example Matrices/' + curr_file\n\t\t\twith open(curr_filepath, 'r') as open_file:\n\t\t\t\tfor line in open_file:\n\t\t\t\t\tif len(line) > 0:\n\t\t\t\t\t\tcurr_matrix = np.matrix(line)\n\t\t\t\t\t\tmatrix_arr.append(curr_matrix)\n\treturn matrix_arr","def get_filenames(is_training, data_dir):\n if is_training:\n return [os.path.join(data_dir, 'LIP_train5.record')]\n else:\n return [os.path.join(data_dir, 'LIP_val5.record')]","def _get_filenames():\n src_dir = os.path.join(FLAGS.dataset_dir, FLAGS.src_dir)\n filenames = [os.path.join(src_dir, f) for f in os.listdir(src_dir) if\n f.endswith(\".tfrecord\") and\n all([blackflag not in f for blackflag in TEMP_BLACK_LIST])]\n shuffle(filenames)\n return filenames","def get_filenames_reid(is_training, data_dir):\n if is_training:\n return [os.path.join(data_dir, 'train-512-170.tfrecords')]\n else:\n return [os.path.join(data_dir, 'val-512-170.tfrecords')]","def list_mat_files(glob_pat):\n fnames = glob.glob(glob_pat)\n #print len(fnames)\n return fnames","def get_atlas_names():\n tar_path = os.path.join(get_data_dir(), 'atlas')\n xml_names = get_file_names(tar_path,'.xml')\n return xml_names","def LoadTroikaDataFile(data_fl):\n data = sp.io.loadmat(data_fl)['sig']\n return data[2:]","def get_filenames(is_training,datadir):\n assert os.path.exists(datadir), (\n 'Can not find data at given directory!!')\n if(is_training):\n labels = []\n data_dir = []\n with open('/home/qnie/PycharmProjects/ntumotion/training_protocol/fEDM_R_CS_trainimgs.txt') as f:\n for line in f:\n data_dir.append(datadir+line.strip())\n f.close()\n\n with open('/home/qnie/PycharmProjects/ntumotion/training_protocol/fEDM_R_CS_trainlabels.txt') as f:\n for line in f:\n labels.append(int(line.strip()))\n f.close()\n else:\n labels = []\n data_dir = []\n with open('/home/qnie/PycharmProjects/ntumotion/training_protocol/fEDM_R_CS_testimgs.txt') as f:\n for line in f:\n data_dir.append(datadir + line.strip())\n f.close()\n\n with open('/home/qnie/PycharmProjects/ntumotion/training_protocol/fEDM_R_CS_testlabels.txt') as f:\n for line in f:\n labels.append(int(line.strip()))\n f.close()\n\n return data_dir, labels","def get_filenames(root_dir):\n from pathlib import Path\n\n file_list = Path(root_dir).rglob('*featuresN.hdf5')\n file_list = [str(file) for file in file_list]\n\n filenames = pd.DataFrame(file_list, columns=['file_name'])\n filenames.insert(0, 'file_id', np.arange(len(file_list)))\n\n return filenames","def get_filenames(is_training, data_dir):\n\n return [ os.path.join(data_dir, 'train_'+str(shard_id)+'.tfrecord') for shard_id in range(_NUM_SHARDS)]","def get_train_files(self):\n train_dir = os.path.join(self.data_dir, \"train_{}\".format(self.patient_no))\n filenames = os.listdir(train_dir)\n interm = ((os.path.splitext(f)[0].split(\"_\"), os.path.join(train_dir, f)) for f in filenames)\n return [(int(p[0][0]), int(p[0][1]), int(p[0][2]), p[1]) for p in interm]","def read_dataset_files(datasetid, clean_folder):\n fnotu = datasetid + '.otu_table.clean.feather'\n fnmeta = datasetid + '.metadata.clean.feather'\n\n df = feather.read_dataframe(os.path.join(clean_folder, fnotu))\n # Feather format does not support index names, first column has index\n df.index = df.iloc[:,0]\n df = df.iloc[:, 1:]\n\n meta = feather.read_dataframe(os.path.join(clean_folder, fnmeta))\n meta.index = meta.iloc[:, 0]\n meta = meta.iloc[:, 1:]\n\n ## Make sure sample names are strings\n if df.index.dtype != 'O':\n df.index = pd.read_csv(os.path.join(clean_folder, fnotu), sep='\\t', dtype=str).iloc[:,0]\n\n if meta.index.dtype != 'O':\n meta.index = pd.read_csv(os.path.join(clean_folder, fnmeta), sep='\\t', dtype=str).iloc[:,0]\n\n return df, meta","def read_dataset_v1():\n path = load_config()\n T = feather.read_dataframe(path['data_dir'] / 'T_dat.feather')\n E = feather.read_dataframe(path['data_dir'] / 'E_dat.feather')\n M = feather.read_dataframe(path['data_dir'] / 'Meta.feather')\n data = sio.loadmat(path['data_dir'] / 'highvar_genes.mat', squeeze_me=True)\n return T, E, M, data","def raw_file_names(self):\n return self.raw_file_names_3d","def gen_datafiles():\n\tnum_reads = 10000\n\tnum_samples = 100\n\tgen_sequences('hg38.fa', num_reads, num_samples, 1, 'hg38_train.txt')\n\tgen_sequences('HIV-1.fasta', num_reads, num_samples, 0, 'HIV-1_train.txt')\n\tgen_sequences('hg38.fa', num_reads, num_samples, 1, 'hg38_test.txt')\n\tgen_sequences('HIV-1.fasta', num_reads, num_samples, 0, 'HIV-1_test.txt')","def get_filenames():\r\n datadir = \"./phase3_data/\"\r\n samples = os.listdir(datadir)\r\n all_files = []\r\n for i in range(len(samples)):\r\n sampfiles = []\r\n datadir = \"./phase3_data/\" + samples[i]\r\n files = os.listdir(datadir)\r\n for file in files:\r\n if file.endswith(\".bin\"):\r\n sampfiles += [file]\r\n all_files += [sampfiles]\r\n return samples, all_files","def return_file_read(_):\n return [\"scorevideo LOG\", \"File: log.mat\"]","def get_images_and_labels(tampered_path, authentic_path):\n tampered_dir = tampered_path\n authentic_dir = authentic_path\n images = {}\n for im in glob.glob(authentic_dir):\n images[im] = {}\n images[im]['mat'] = cv2.imread(im)\n images[im]['label'] = 0\n for im in glob.glob(tampered_dir):\n images[im] = {}\n images[im]['mat'] = cv2.imread(im)\n images[im]['label'] = 1\n return images","def files():\r\n fn=pd.read_csv(request.files.get('fnm'))\r\n scaling = scaler.transform(fn)\r\n prediction = classifier.predict(scaling)\r\n return 'Predictions'+ str(list(prediction))","def get_filenames(self):\n return [doc['filename'] for doc in self.vocab]","def img_filenames(self, matricule):\n proj, sid = next((proj, proj.Matricule(matricule).to('AmcStudentId'))\n for proj in self.projects_by_serie.values()\n if proj.Matricule(matricule).exists('AmcStudentId'))\n return [\n (int(num), filename.replace('%PROJET', proj.path))\n for num, filename in proj.dbs['capture'].execute('select page, src from capture_page where student=? order by page', [sid])\n ]","def getFilePaths():\n \n image_dir = r'/hpc/wfok007/mpi_heart/Training Set'\n mask_paths = []\n image_paths = []\n for root, dirs, files in os.walk(image_dir, topdown=False):\n for name in files:\n if name == 'laendo.nrrd':\n mask_paths.append(os.path.join(root, name))\n elif name == 'lgemri.nrrd':\n image_paths.append(os.path.join(root, name))\n else:\n print ('%s is unknown' %name)\n return mask_paths, image_paths","def inputFiles(self):\n return (self.matrixFile,)","def get_filename_data_readers(image_ids_file, get_labels=False,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tx_jpg_dir=None, y_png_dir=None):\n\tx_jpg_dir = x_jpg_dir or os.path.join(FLAGS.data_dir, 'images')\n\ty_png_dir = y_png_dir or os.path.join(FLAGS.data_dir, 'tf_segmentation')\n\t# TODO(student): Write code.\n\n\tlines_dataset = tf.data.TextLineDataset(image_ids_file)\n\timages_dataset = lines_dataset.map(lambda x: x_jpg_dir + os.path.sep + x + '.jpg')\n\tif get_labels:\n\t\tlabels_dataset = lines_dataset.map(lambda x: y_png_dir + os.path.sep + x + '.png')\n\t\treturn images_dataset, labels_dataset\n\telse:\n\t\treturn images_dataset","def load_data():\n\n training_files_dir = \"digits/trainingDigits\"\n training_files = os.listdir(training_files_dir)\n file_num = len(training_files)\n hw_labels = []\n\n training_mat = zeros((file_num, 32 * 32))\n for i in xrange(file_num):\n filename = training_files[i]\n file_label = int((filename.split(\".\")[0]).split(\"_\")[0])\n hw_labels.append(file_label)\n training_mat[i, :] = img2vector(training_files_dir + '/' + filename)\n\n return training_mat, hw_labels","def get_data_path():\n up_folder = os.path.abspath(os.path.join(ROOT_DIR, '..'))\n img_folder = os.path.join(up_folder, 'data_set', 'XX-ImageLabel', 'train_data_416')\n img_file = os.path.join(DATA_DIR, \"t_img_tags_train.txt\") # 数据类别\n return img_folder, img_file","def get_filenames(self):\n if self.mode == tf.estimator.ModeKeys.TRAIN:\n lookup_name = 'train'\n elif self.mode == tf.estimator.ModeKeys.EVAL:\n lookup_name = 'validation'\n elif self.mode == tf.estimator.ModeKeys.PREDICT:\n lookup_name = self.predict_split\n filenames = tf.gfile.Glob(\n os.path.join(self.data_dir, '{}-*-of-*'.format(lookup_name)))\n if tf.estimator.ModeKeys.PREDICT:\n # Sort so that TFRecords will be read out deterministically.\n filenames = sorted(filenames)\n return filenames","def get_filenames(self):\n if self.mode == tf.estimator.ModeKeys.TRAIN:\n lookup_name = 'train'\n elif self.mode == tf.estimator.ModeKeys.EVAL:\n lookup_name = 'validation'\n elif self.mode == tf.estimator.ModeKeys.PREDICT:\n lookup_name = self.predict_split\n filenames = tf.gfile.Glob(\n os.path.join(self.data_dir, '{}-*-of-*'.format(lookup_name)))\n if tf.estimator.ModeKeys.PREDICT:\n # Sort so that TFRecords will be read out deterministically.\n filenames = sorted(filenames)\n return filenames","def import_data(hdfile, didx=0, dpath=BASE_PATH, PASS=False, dname='LMD'):\n dset = Dataset(hdfile)\n \n genres = {}\n for f in collect_mat_files(dpath,dname, didx):\n data = loadmat(f)\n g = data['genre'][0]\n print f\n if not g in genres:\n genres[g] = len(genres)\n \n if not PASS:\n x = data['features'].T\n dset.add_data(X=[x],y=[genres[g]],\n metadata=[{'filename':os.path.split(f)[-1]}])\n \n return genres","def gather_dataset_names(path_to_files, project_name, suffix):\r\n species_trees_list = list_files_in_given_folder(path_to_files)\r\n dataset_names = extract_dataset_names(species_trees_list, project_name, suffix)\r\n return dataset_names","def data_set_maker():\n\n # crate a folder in your code directory and name it: \"files\". put the .npy files iside that folder\n path = os.getcwd() # reads the current path\n x_train = np.load(path + '/files/tinyX.npy', 'r') # reads the input file\n y_train = np.load(path + '/files/tinyY.npy', 'r') # reads the input file\n x_test = np.load(path + '/files/tinyX_test.npy', 'r') # reads the input file\n x_train, y_train = shuffle(x_train, y_train)\n\n return x_train, y_train, x_test","def getTiffAsMatrix(kv):\n file_name = kv[0].split('/')[-1]\n fbinary = kv[1]\n tiffmat = getOrthoTif(fbinary)\n return (file_name,tiffmat)","def _get_file_paths(self):\n return [os.path.join(self.path, self.mode, 'waveforms', file_name + '.npy') for file_name in self.file_names]","def read_file_names(self):\n files_BIDMC = os.listdir(self.root_dir_BIDMC)\n masks_BIDMC = os.listdir(self.seg_dir_BIDMC)\n files_HK = os.listdir(self.root_dir_HK)\n masks_HK = os.listdir(self.seg_dir_HK)\n files_I2CVB = os.listdir(self.root_dir_I2CVB)\n masks_I2CVB = os.listdir(self.seg_dir_I2CVB)\n files_ISBI = os.listdir(self.root_dir_ISBI)\n masks_ISBI = os.listdir(self.seg_dir_ISBI)\n files_ISBI_15 = os.listdir(self.root_dir_ISBI_15)\n masks_ISBI_15 = os.listdir(self.seg_dir_ISBI_15)\n files_UCL = os.listdir(self.root_dir_UCL)\n masks_UCL = os.listdir(self.seg_dir_UCL)\n site_files = [files_BIDMC, files_HK, files_I2CVB, files_ISBI, files_ISBI_15, files_UCL]\n site_masks = [masks_BIDMC, masks_HK, masks_I2CVB, masks_ISBI, masks_ISBI_15, masks_UCL]\n return site_files, site_masks","def read_fn(file_references, mode, params=None):\r\n print('Reading the dataset from Datalakestore (2mm NIfTI images)....')\r\n\r\n def _augment(img):\r\n \"\"\"An image augmentation function\"\"\"\r\n return flip(img, axis=2)\r\n\r\n image_array = []\r\n label_array = []\r\n for f in file_references:\r\n subject_id = f[0]\r\n\r\n # Read the image nii with sitk\r\n ##t1_fn = os.path.join(data_path, '{}/T1_2mm.nii.gz'.format(subject_id))\r\n ##t1 = sitk.GetArrayFromImage(sitk.ReadImage(str(t1_fn)))\r\n t1_fn = os.path.join(data_path, '{}/T1_2mm.nii.gz'.format(subject_id))\r\n print(t1_fn)\r\n #with adlsFileSystemClient.open(t1_fn, 'rb') as f:\r\n # img = sitk.ReadImage(str(f))\r\n # sitk::ERROR: The file \"<ADL file: /clusters/DLTK_IXI_Dataset/2mm/IXI012/T1_2mm.nii.gz>\" does not exist.\r\n # sitk seems only read from local path....how to read from remote path????????\r\n # for short term download to local path\r\n # rpath is datalakestore, lpath is local file path both have the same root structure '/clusters/DLTK_IXI_Dataset/'\r\n multithread.ADLDownloader(adlsFileSystemClient, rpath=t1_fn, lpath=t1_fn, nthreads=5, chunksize=2**24, overwrite=True)\r\n img = sitk.ReadImage(str(t1_fn))\r\n # you need http://imagej.net/Fiji#Downloads app to show the img. More discussion and instruction: https://stackoverflow.com/questions/45682319/simpleitk-show-generates-error-in-imagej-on-linux\r\n ##sitk.Show(img)\r\n t1 = sitk.GetArrayFromImage(img)\r\n\r\n # Normalise volume image\r\n t1 = whitening(t1)\r\n images = np.expand_dims(t1, axis=-1).astype(np.float32)\r\n\r\n if mode == tf.estimator.ModeKeys.PREDICT:\r\n yield {'features': {'x': images}, 'img_id': subject_id}\r\n print('read_fn Predict')\r\n\r\n # Parse the sex classes from the file_references [1,2] and shift them\r\n # to [0,1]\r\n sex = np.int(f[1]) - 1\r\n y = np.expand_dims(sex, axis=-1).astype(np.int32)\r\n\r\n # Augment if used in training mode\r\n if mode == tf.estimator.ModeKeys.TRAIN:\r\n images = _augment(images)\r\n print('read_fn Train')\r\n # Check if the reader is supposed to return training examples or full images\r\n if params['extract_examples']:\r\n #print('read_fn params extract_examples')\r\n images = extract_random_example_array(\r\n image_list=images,\r\n example_size=params['example_size'],\r\n n_examples=params['n_examples'])\r\n for e in range(params['n_examples']):\r\n #print ('e: ', e)\r\n## yield {'features': {'x': images[e].astype(np.float32)},\r\n## 'labels': {'y': y.astype(np.float32)},\r\n## 'img_id': subject_id}\r\n image_array.append(images[e].astype(np.float32))\r\n label_array.append(y.astype(np.int32))\r\n else:\r\n print('read_fn params yield last')\r\n## yield {'features': {'x': images},\r\n## 'labels': {'y': y.astype(np.float32)},\r\n## 'img_id': subject_id}\r\n image_array.append(images)\r\n label_array.append(y.astype(np.int32))\r\n\r\n print(\"read_fn yield output_array with image shape = \", images.shape, \"label shape = \", y.shape)\r\n yield {'x': np.array(image_array), 'y': np.array(label_array)}","def get_data(path):\n all_images_as_array=[]\n label=[]\n for filename in os.listdir(path):\n try:\n if re.match(r'positive',filename):\n label.append(1)\n else:\n label.append(0)\n img=cv2.imread(path + filename)\n (b, g, r)=cv2.split(img)\n img=cv2.merge([r,g,b])\n np_array = np.asarray(img)\n l,b,c = np_array.shape\n np_array = np_array.reshape(l*b*c,)\n all_images_as_array.append(np_array)\n except:\n continue\n return np.array(all_images_as_array), np.array(label)","def get_filenames(is_training, data_dir):\n if is_training:\n return [\n os.path.join(data_dir, 'train-%05d-of-01024' % i)\n for i in range(_NUM_TRAIN_FILES)]\n else:\n return [\n os.path.join(data_dir, 'validation-%05d-of-00128' % i)\n for i in range(_NUM_VAL_FILES)]","def read_dataset(path_to_dataset_folder, index_filename):\n ###############################################################\n # Fill your code in this function\n ###############################################################\n # Hint: open(path_to_dataset_folder+'/'+index_filename,'r')\n with open(path_to_dataset_folder + '/' + index_filename, 'r') as index_file:\n lines = index_file.readlines()\n txt_paths = {}\n for line in lines:\n txt_path = line.split()\n txt_paths[txt_path[1]] = txt_path[0]\n\n A = []\n T = []\n for sample_file, label in txt_paths.items():\n A_16dim = []\n with open(path_to_dataset_folder + '/' + sample_file, 'r') as dim_values:\n lines = dim_values.readlines()\n for line in lines:\n dim_value = line.split()\n A_helper = [1]\n for element in dim_value:\n A_helper.append(float(element))\n A.append(A_helper)\n label = int(label)\n T_helper = [label]\n T.append(T_helper)\n A = np.array(A)\n T = np.array(T)\n return A, T","def list_datasets():\n return METADATA.keys()","def list_dataset(filename, type = 'roi'):\n import os\n import numpy as np\n\n root,camera_name,dataset_name,chunk,extension = split_raw_filename(filename)\n lst_dir = os.listdir(root)\n lst_dataset = []\n lst_order = []\n for item in lst_dir:\n if item.find(camera_name+'_'+dataset_name + '_') != -1:\n rt,camera_name,dataset_name,chunk,extension = split_raw_filename(item)\n if extension == f\"{type}.hdf5\":\n lst_dataset.append(os.path.join(root,item))\n lst_order.append(int(chunk))\n lst_sorted = np.argsort(np.array(lst_order))\n return list(np.array(lst_dataset)[lst_sorted])","def load_data(animal, selection, verbose=False):\r\n\tpath_raw = os.path.join(paths.path2Data, animal, 'Raw Data')\r\n\t\r\n\traw_paths = [os.path.join(path_raw, file) for file in ['ROIBinmaps_{0}.mat'.format(animal), 'ALLDFF.mat', 'ALLBEHmatrix.mat', 'ALLf0.mat']]\r\n\r\n\tmeta_df = pd.read_csv(os.path.join(path_raw, 'meta_df.csv'), index_col=0)\r\n\t\r\n\t# Load matrices as dictionnary {name: matrix_values}\r\n\troi_file, raw_mat, raw_beh, f0 = list(map(loadmat, raw_paths))\r\n\t\r\n\t# Indexing data of interest\r\n\troi_tensor = roi_file['ROIBinmaps']\r\n\r\n\t# Remove the first second of acquisition\r\n\tacti = raw_mat['ALLDFF'][:,15:,:]\r\n\t\r\n\tf0 = f0['F0ALL']\r\n\r\n\tif verbose: \r\n\t\tN, T, K = acti.shape\r\n\t\tprint('Data contain activity of', N, 'ROI, on a time scale of', T/15, 'seconds, during', K, 'trials')\r\n\r\n\treturn meta_df, roi_tensor, acti, f0","def get_datasets(data):\n train_dataset, test_dataset = None, None\n data_dir = '../data'\n\n if data == 'fmnist':\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean=[0.2860], std=[0.3530])])\n train_dataset = datasets.FashionMNIST(data_dir, train=True, download=True, transform=transform)\n test_dataset = datasets.FashionMNIST(data_dir, train=False, download=True, transform=transform)\n \n elif data == 'fedemnist':\n train_dir = '../data/Fed_EMNIST/fed_emnist_all_trainset.pt'\n test_dir = '../data/Fed_EMNIST/fed_emnist_all_valset.pt'\n train_dataset = torch.load(train_dir)\n test_dataset = torch.load(test_dir) \n \n elif data == 'cifar10':\n transform_train = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),\n ])\n transform_test = transforms.Compose([\n transforms.ToTensor(),\n transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),\n ])\n train_dataset = datasets.CIFAR10(data_dir, train=True, download=True, transform=transform_train)\n test_dataset = datasets.CIFAR10(data_dir, train=False, download=True, transform=transform_test)\n train_dataset.targets, test_dataset.targets = torch.LongTensor(train_dataset.targets), torch.LongTensor(test_dataset.targets) \n \n return train_dataset, test_dataset","def read_mat_file(filename):\n mat_contents = sio.loadmat(filename)\n image_data = mat_contents['image']['img'][0, 0]\n return image_data","def get_memes_data(path):\n data = load_files(path)\n memes = np.array(data['filenames'])\n return memes","def _get_dataset_contents(self,\n dataset_root_path: str,\n property_alias: str) -> Tuple[np.ndarray, np.ndarray, List[int], List[str]]:\n cur_dir = os.getcwd()\n os.chdir(dataset_root_path) # the parent folder with sub-folders\n\n list_fams, no_imgs, num_samples = self._get_labels_info(property_alias)\n\n y, indexes = self._fetch_labels(list_fams, no_imgs, num_samples)\n X, samples_names = self._get_X_and_names(list_fams, num_samples, property_alias)\n\n os.chdir(cur_dir)\n\n return X, y, indexes, samples_names","def samples(self):\n return glob.glob(os.path.join(self.production.rundir, \"extrinsic_posterior_samples.dat\"))","def get_test_files(self):\n test_images = np.array(\n glob('/media/data_cifs/pytorch_projects/datasets/BSDS500_crops/data/images/test_nocrop/*.jpg'))\n test_labels = np.array(\n [x.replace('images', 'groundTruth').replace('.jpg', '.npy') for x in test_images])\n test_labels = np.array(\n [np.load(x) for x in test_labels])\n keep_idx = np.array([True if x.shape[0] > x.shape[1] else False for x in test_labels])\n test_images = test_images[keep_idx]\n return test_images","def get_filenames(mode, data_dir):\n if mode == 'train':\n return [os.path.join(data_dir, 'encoder.train.input'), os.path.join(data_dir, 'encoder.train.target'),\n os.path.join(data_dir, 'decoder.train.target')]\n else:\n return [os.path.join(data_dir, 'encoder.test.input'), os.path.join(data_dir, 'encoder.test.target'),\n os.path.join(data_dir, 'decoder.test.target')]","def files_debug(dirfiles):\r\n\r\n files_path = {}\r\n \r\n normal_folder = [\"K002\"]\r\n OR_folder = [\"KA01\"]\r\n IR_folder = [\"KI01\"]\r\n MIX_folder = [\"KB23\"] # VERIFICAR\r\n\r\n settings_files = [\"N15_M07_F10_\", \"N09_M07_F10_\", \"N15_M01_F10_\", \"N15_M07_F04_\"]\r\n\r\n n = 20\r\n\r\n # Normal\r\n for folder in normal_folder:\r\n for idx, setting in enumerate(settings_files):\r\n for i in range(1, n+1):\r\n key = \"Normal_\" + folder + \"_\" + str(idx) + \"_\" + str(i)\r\n files_path[key] = os.path.join(dirfiles, folder, setting + folder +\r\n \"_\" + str(i) + \".mat\")\r\n\r\n # OR\r\n for folder in OR_folder:\r\n for idx, setting in enumerate(settings_files):\r\n for i in range(1, n+1):\r\n key = \"OR_\" + folder + \"_\" + str(idx) + \"_\" + str(i)\r\n files_path[key] = os.path.join(dirfiles, folder, setting + folder +\r\n \"_\" + str(i) + \".mat\")\r\n\r\n # IR\r\n for folder in IR_folder:\r\n for idx, setting in enumerate(settings_files):\r\n for i in range(1, n+1):\r\n key = \"IR_\" + folder + \"_\" + str(idx) + \"_\" + str(i)\r\n files_path[key] = os.path.join(dirfiles, folder, setting + folder +\r\n \"_\" + str(i) + \".mat\")\r\n\r\n return files_path","def load_labeled_data():\n\n images = []\n labels = []\n\n for i in range(1, 10):\n path = (\"selflabeled\", str(i), \"*.jpg\")\n filenames = glob.glob(\"/\".join(path))\n images_one_type = [cv2.imread(img) for img in filenames]\n labels_one_type = [i] * len(images_one_type)\n images += images_one_type\n labels += labels_one_type\n\n return images, labels","def get_train_data(data, lang):\n train_files = open(os.path.join('traintestsplit', lang+'.trainlist')).read().split()\n return [data[lang][filename+'.npytxt'] for filename in train_files]","def readmnist(dataset = \"training\", path = \".\"):\n\n if dataset is \"training\":\n fname_img = os.path.join(path, 'train-images.idx3-ubyte')\n fname_lbl = os.path.join(path, 'train-labels.idx1-ubyte')\n elif dataset is \"testing\":\n fname_img = os.path.join(path, 't10k-images.idx3-ubyte')\n fname_lbl = os.path.join(path, 't10k-labels.idx1-ubyte')\n # else:\n # raise ValueError, \"dataset must be 'testing' or 'training'\"\n\n # Load everything in some numpy arrays\n with open(fname_lbl, 'rb') as flbl:\n magic, num = struct.unpack(\">II\", flbl.read(8))\n lbl = np.fromfile(flbl, dtype=np.int8)\n\n with open(fname_img, 'rb') as fimg:\n magic, num, rows, cols = struct.unpack(\">IIII\", fimg.read(16))\n img = np.fromfile(fimg, dtype=np.uint8).reshape(len(lbl), rows, cols)\n\n get_img = lambda idx: (lbl[idx], img[idx])\n\n # Create an iterator which returns each image in turn\n for i in xrange(len(lbl)):\n yield get_img(i)","def KittiTestDataset(test_root_path):\n \n names = os.listdir(test_root_path)\n dataset = [[os.path.join(test_root_path, name)] for name in names]\n \n return dataset","def load_matrices(index, field):\n cov_root = os.path.join(file_root, 'CovMatricesAll/')\n suffix2 = '_n%d_m%d_%s%s_%s.txt' % (n, m, field, field, index)\n suffix3 = '_n%d_m%d_%s,%s%s_%s.txt' % (n, m, field, field, field, index)\n suffix4 = '_n%d_m%d_%s%s,%s%s_%s.txt' % (n, m, field, field, field, field, index)\n c2 = np.diag(np.loadtxt(cov_root + 'c2' + suffix2)[skip_bins:])\n c3 = np.loadtxt(cov_root + 'c3' + suffix3)[skip_bins:, skip_bins:]\n c4 = np.loadtxt(cov_root + 'c4' + suffix4)[skip_bins:, skip_bins:]\n\n # Now symmetrize and return matrices\n return c2, 0.5*(c3+c3.T), 0.5*(c4+c4.T)","def gene_txt_of_load(dirname):\n str_list=[]\n list_name=[]\n print 'Yolo Debut'\n for file in os.listdir(dirname):\n if file.endswith(\".npy\"):\n str_list.append(file[:-4]+'=np.load(dirname+'+'\\\"/\\\"'+'+\\\"'+file+'\\\")')\n list_name.append(file[:-4])\n print '\\n'.join(str_list)\n print ','.join(list_name)\n return str_list","def write_all_patients():\n\n data_dir = sys.argv[1]\n output_dir = sys.argv[2]\n\n imgs, i_msks, o_msks = load_all_patients(data_dir=data_dir)\n\n for idx, array in enumerate(imgs):\n np.save(output_dir+'/img_'+str(idx), array)\n for idx, array in enumerate(i_msks):\n np.save(output_dir+'/i_msk_'+str(idx), array)\n for idx, array in enumerate(o_msks):\n np.save(output_dir + '/o_msk_' + str(idx), array)\n\n return None","def load_matrices(self):\n self.wine_matrix = np.array(self.parse_file_into_array('winequality-red.csv', ';'))\n self.cancer_matrix = np.array(self.parse_file_into_array('breast-cancer-wisconsin.data', ','))","def get_labels():\n return [name for name in os.listdir(os.getcwd() + '/assets/images') if name != 'test']","def get_torch_dataset_images_labels(data_dir):\r\n\r\n # Transforms for testing sets\r\n test_transforms = transforms.Compose([transforms.Resize(255),\r\n transforms.CenterCrop(224),\r\n transforms.ToTensor(),\r\n transforms.Normalize((0.485, 0.456, 0.406),\r\n (0.229, 0.224, 0.225))])\r\n\r\n # Definition of testing datasets using ImageFolder\r\n test_datasets = datasets.ImageFolder(data_dir, transform=test_transforms)\r\n\r\n return test_datasets.imgs","def datasets(self):\n return [Dataset.GWAS_CATALOG, Dataset.CLINVAR, Dataset.EFO]","def getAllFileNames(self):\n #images = [\"image1.jpg\",\"image2.jpg\",\"image3.jpg\"]\n \n os.chdir(self.dataDir)\n filenames = glob.glob(\"*.*\")\n filenames.sort() \n return filenames","def get_dataset_files(dataset_info, mode, root):\n basepath = dataset_info.basepath\n base = os.path.join(root, basepath, mode)\n\n # usually of form '{}-of-{}.tfrecord'\n files = sorted(os.listdir(base))\n\n return [os.path.join(base, file) for file in files]","def get_path_and_label(self):\n DATA_SIZE = 700\n category = os.listdir(os.path.join(self.root, 'NWPU-RESISC45'))\n image_path = []\n label = []\n for cat in category:\n cat_enc = self.class_enc[cat]\n label += [cat_enc] * DATA_SIZE\n for num in range(1, DATA_SIZE+1):\n filename = cat + '_' + str(num).zfill(3) + '.jpg'\n image_path += [os.path.join(self.root,\n 'NWPU-RESISC45', cat, filename)]\n df = pd.DataFrame({'image': image_path, 'label': label})\n\n return df","def get_filename(images):\n image_file = {}\n for image in images:\n image_file[image['id']] = os.path.join('train2017', image['file_name'])\n return image_file","def get_path_and_label(self):\n image_path = []\n label = []\n\n for image in glob.glob(os.path.join(self.root,self.data_mode,'*_photo.png')):\n image_path.append(image)\n \n for mask in glob.glob(os.path.join(self.root,self.data_mode,'*_mask.png')):\n label.append(mask)\n\n df = pd.DataFrame({'image': sorted(image_path), 'label': sorted(label)})\n\n return df","def explore_data():\n labels = [\"vehicles\", \"non-vehicles\"]\n labelmap = {0: \"vehicles\", 1: \"non-vehicles\"}\n vehicles_glob = os.path.join(data_dir, \"vehicles\", \"**\", \"*.png\")\n nonvehicles_glob = os.path.join(data_dir, \"non-vehicles\", \"**\", \"*.png\")\n class_fnames = [\n glob.glob(vehicles_glob, recursive = True),\n glob.glob(nonvehicles_glob, recursive = True)]\n n_samples = [len(fnames) for fnames in class_fnames]\n shapes = []\n samples = []\n print(table_format([\"label\", \"size\", \"shape\"], header = True))\n for label, fnames in enumerate(class_fnames):\n indices = np.random.choice(len(fnames), 4*10, replace = False)\n for i in indices:\n fname = fnames[i]\n img = cv2.imread(fname)\n samples.append(img)\n shape = img.shape\n shapes.append(shape)\n print(table_format([labels[label], n_samples[label], shapes[label]]))\n\n samples = np.stack(samples)\n samples = tile(samples, 2*4, 10)\n cv2.imwrite(os.path.join(out_dir, \"datasamples.png\"), samples)\n\n return class_fnames, labelmap","def raw_file_names_3d(self):\n return [self.id_to_relative_raw_path(x) for x in self.cloud_ids]","def _setup_data_filenames(self):\n\n # read in filenames of training data(poses, images, labels)\n logging.info('Reading filenames')\n all_filenames = os.listdir(self.data_dir)\n if self.image_mode== ImageMode.BINARY:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.binary_im_tensor_template) > -1]\n elif self.image_mode== ImageMode.DEPTH:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tensor_template) > -1]\n elif self.image_mode== ImageMode.BINARY_TF:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.binary_im_tf_tensor_template) > -1]\n elif self.image_mode== ImageMode.COLOR_TF:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.color_im_tf_tensor_template) > -1]\n elif self.image_mode== ImageMode.GRAY_TF:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.gray_im_tf_tensor_template) > -1]\n elif self.image_mode== ImageMode.DEPTH_TF:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tf_tensor_template) > -1]\n elif self.image_mode== ImageMode.DEPTH_TF_TABLE:\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tf_table_tensor_template) > -1]\n else:\n raise ValueError('Image mode %s not supported.' %(self.image_mode))\n\n self.pose_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.hand_poses_template) > -1]\n self.label_filenames = [f for f in all_filenames if f.find(self.target_metric_name) > -1]\n\n self.im_filenames.sort(key = lambda x: int(x[-9:-4]))\n self.pose_filenames.sort(key = lambda x: int(x[-9:-4]))\n self.label_filenames.sort(key = lambda x: int(x[-9:-4]))\n\n # check that all file categories were found\n if len(self.im_filenames) == 0 or len(self.label_filenames) == 0 or len(self.label_filenames) == 0:\n raise ValueError('1 or more required training files could not be found')","def load_data():\n prefix = 'mnist_data/'\n train_data = np.load(prefix + 'mnist_train_images.npy')\n train_labels = np.load(prefix + 'mnist_train_labels.npy')\n val_data = np.load(prefix + 'mnist_validation_images.npy')\n val_labels = np.load(prefix + 'mnist_validation_labels.npy')\n test_data = np.load(prefix + 'mnist_test_images.npy')\n test_labels = np.load(prefix + 'mnist_test_labels.npy')\n assert train_data.shape == (55000, 784) and train_labels.shape == (55000, 10)\n assert val_data.shape == (5000, 784) and val_labels.shape == (5000, 10)\n assert test_data.shape == (10000, 784) and test_labels.shape == (10000, 10)\n return train_data, train_labels, val_data, val_labels, test_data, test_labels","def label_names_file():\n return tfds.core.tfds_path(_LABELS_FNAME)","def read_models():\n model_files_cvd = np.sort(glob.glob(\"./grad_results/cvd*N1024_f0003.npy\"))\n model_files_mnist = np.sort(glob.glob(\"./grad_results/mnist*N25000_f02.npy\"))\n\n model_files_cvd = np.array([model_files_cvd[2], model_files_cvd[1], model_files_cvd[0]])\n\n results_cvd = []\n results_mnist = []\n\n for filename in model_files_cvd:\n results_cvd.append(np.load(filename))\n \n for filename in model_files_mnist:\n results_mnist.append(np.load(filename))\n\n return np.array(results_mnist), np.array(results_cvd)","def test_get_dataset_path(self) -> None:\n framework = \"tensorflow\"\n domain = \"image_recognition\"\n result = get_dataset_path(framework, domain)\n self.assertEqual(result, \"examples/test/dataset/imagenet\")","def getDatasets(fileinformation):\n filedata = pd.read_csv(fileinformation, sep=\"\\t\", header=None)\n datalabels = list(filedata.iloc[:,0].values)\n datafiles = list(filedata.iloc[:,1].values)\n return datalabels, datafiles","def get_data(folder):\n X = []\n y = []\n for folderName in os.listdir(folder):\n if not folderName.startswith('.'):\n if folderName in ['NORMAL']:\n label = 0\n elif folderName in ['CNV']:\n label = 1\n elif folderName in ['DME']:\n label = 2\n elif folderName in ['DRUSEN']:\n label = 3\n else:\n label = 4\n for image_filename in tqdm(os.listdir(folder + folderName)):\n img_file = cv2.imread(folder + folderName + '/' + image_filename)\n if img_file is not None:\n img_file = skimage.transform.resize(img_file, (imageSize, imageSize, 3))\n img_arr = np.asarray(img_file)\n X.append(img_arr)\n y.append(label)\n X = np.asarray(X)\n y = np.asarray(y)\n return X,y","def get_filename_dataset(self, data_dir):\n # Get filenames\n data_dir = pathlib.Path(data_dir)\n list_ds = tf.data.Dataset.list_files(str(data_dir / '*'))\n\n # Create data pre-processing functions\n funcs = self._get_data_preprocessing_fns()\n\n # Get FAKE labeled dataset\n ds = list_ds.map(funcs.process_img_path, num_parallel_calls=AUTOTUNE)\n # Format conversion\n ds = ds.map(funcs.convert_format, num_parallel_calls=AUTOTUNE)\n # Resizing\n ds = ds.map(funcs.resize, num_parallel_calls=AUTOTUNE)\n\n # Batch, prefetch\n ds = ds.batch(1)\n\n return ds","def get_data_files():\n data_files = []\n\n # Walk through the data directory, adding all files\n data_generator = os.walk('pypeit/data')\n for path, directories, files in data_generator:\n for f in files:\n data_path = '/'.join(path.split('/')[1:])\n data_files.append(os.path.join(data_path, f))\n\n # Add pipeline and spectrograph settings\n settings = glob.glob('pypeit/settings/settings.*')\n settings = ['/'.join(path.split('/')[1:]) for path in settings]\n data_files.extend(settings)\n\n return data_files","def read_state_matrices():\r\n drum_mats = glob.glob('./Melody_Bass_Data/*_bass.txt')\r\n melody_mats = glob.glob('./Melody_Bass_Data/*_melody.txt')\r\n \r\n drum_states = []\r\n melody_states = []\r\n\r\n for drum_mat,melody_mat in zip(drum_mats[:20],melody_mats[:20]):\r\n temp= np.genfromtxt(drum_mat)\r\n drum_states.append(temp)\r\n temp= np.genfromtxt(melody_mat)\t\r\n melody_states.append(temp)\r\n \r\n return drum_states,melody_states","def get_data(folder):\n X = []\n y = []\n\n for seismic_type in os.listdir(folder):\n if not seismic_type.startswith('.'):\n if seismic_type in ['Class1']:\n label = '0'\n else:\n label = '1'\n for image_filename in os.listdir(folder + seismic_type):\n img_file = cv2.imread(folder + seismic_type + '/' + image_filename)\n if img_file is not None:\n # Downsample the image to 120, 160, 3\n #img_file = scipy.misc.imresize(arr=img_file, size=(120, 160, 3))\n img_arr = np.asarray(img_file)\n # img_arr = image.img_to_array(img_arr)\n X.append(img_arr)\n y.append(label)\n X = np.asarray(X)\n y = np.asarray(y)\n return X,y","def get_spike_data():\n neuron_spikes = []\n first = 0\n last = 0\n for i, file in enumerate(os.listdir(\"\"\"/Users/markusekvall/Desktop/\n final_entropy_model/Spike_trains\"\"\")):\n if file.endswith(\".mat\"):\n if file[0] == \".\":\n continue\n else:\n x = sio.loadmat(os.path.join(\"./Spike_trains\", file))\n cluster_class = x[\"cluster_class\"]\n # Set to ==2 if you want the second cluster\n idx = [cluster_class[:, 0] == 1]\n spike = cluster_class[idx[0], 1]\n if np.size(spike) != 0:\n if max(spike) > last:\n last = max(spike)\n if min(spike) > last:\n first = min(spike)\n neuron_spikes.append(spike)\n return neuron_spikes, first, last","def get_data(self):\n\n if not self.checked:\n self.check_cache()\n h5f = h5py.File(self.data_filename, 'r')\n train_lbl = h5f['train_lbl'][:]\n train_img = h5f['train_img'][:]\n val_lbl = h5f['val_lbl'][:]\n val_img = h5f['val_img'][:]\n h5f.close()\n return train_img, train_lbl, val_img, val_lbl","def __get_dataset_name(self):\n d = gdal.Open(self.fname)\n # Get band metadata\n b = d.GetRasterBand(1)\n md = b.GetMetadata()\n\n if 'data_var' in md:\n return md['data_var']\n else:\n fnames = d.GetFileList()\n if len(fnames) > 2:\n d = gdal.Open(fnames[1])\n # Get band metadata\n b = d.GetRasterBand(1)\n md = b.GetMetadata()\n if 'data_var' in md:\n return md['data_var']\n else:\n return 'data'\n else:\n return 'data'","def get_matrices(training_set_path):\n if os.path.isfile(training_set_path):\n X = HDF5Matrix(training_set_path, 'input/input')\n y = HDF5Matrix(training_set_path, 'target/target')\n y_seg = HDF5Matrix(training_set_path, 'seg_map/seg_map')\n return X, y, y_seg\n else:\n raise Exception('Training set file not found.')","def read_files_and_visualize(data):\n\n image = cv2.imread(data[0])\n label = cv2.imread(data[1], 0)\n name = data[1].split('/')[-1].split('.')[0]\n obj_label = None\n\n if generator_options.save_label_preview:\n obj_label = []\n if os.path.isfile(data[2]):\n with open(data[2], 'r') as f:\n obj = csv.reader(f, delimiter=',')\n for row in obj:\n row = [int(r.split('.')[0]) if index != 0 else r\n for index, r in enumerate(row)]\n obj_label.append(row)\n\n else:\n label_vals = np.unique(label)\n for val in label_vals:\n obj_label.append([_LABEL_DEF_FULL[val], 0, 0, 0, 0])\n\n save_visuals(image, label, obj_label, name)","def load_data():\n\n print('Loading and Visualizing Data ...')\n\n file_name = path.join(getcwd(), 'ex3', 'src', 'data', 'ex3data1')\n data = scipy.io.loadmat(file_name)\n\n # training data stored in arrays X, y\n # y should be a row vector of labels\n return data['X'], data['y'].T[0]","def read_data_sets_label(data_dir, label):\n train_data, test_data = read_data_sets(data_dir, one_hot=False)\n train_mask = create_mask(train_data, label)\n test_mask = create_mask(test_data, label)\n return (train_data.images[train_mask], test_data.images[test_mask])","def _get_all_files(self):\n file_pattern = _FILE_PATTERN\n file_pattern = os.path.join(self.dataset_dir,\n file_pattern % self.split_name)\n return tf.gfile.Glob(file_pattern)","def import_func(path_):\n\n datasets_dic = {}\n\n for dataset_path in path_:\n # Parse labels from filenames\n dataset_label = os.path.split(dataset_path)[1].split('.')[0]\n\n # Read from csv to Pandas\n dataset = pd.read_csv(dataset_path)\n\n # insert dataset label to the dataframes\n dataset.insert(0, 'trial', dataset_label)\n dataset.insert(0, 'maneuver', dataset_label.split('_')[0])\n\n # Datasets are stored in a dictionary\n datasets_dic.update({dataset_label: dataset})\n\n # list of imported maneuvers\n dataset_names = list(datasets_dic.keys())\n\n return datasets_dic, dataset_names","def get_list_of_data_and_labels():\n list_of_imgs = []\n list_of_img_labels = []\n for root, dirs, files in os.walk(config[\"PathToData\"], topdown=False):\n for f in files:\n ext = os.path.splitext(f)[-1].lower()\n\n if ext in config[\"ValidImageFileExtensions\"]:\n list_of_imgs.append(os.path.join(root, f))\n if ext in config[\"ValidLabelFileExtensions\"]:\n list_of_img_labels.append(os.path.join(root, f))\n\n list_of_imgs_with_labels = []\n list_of_corresponing_labels = []\n for img_full_file_name in list_of_imgs:\n img_file_name = os.path.splitext(img_full_file_name)[0].lower()\n corresponding_label = [label_full_file_name for label_full_file_name in list_of_img_labels if os.path.splitext(label_full_file_name)[0].lower() == img_file_name]\n if len(corresponding_label) != 0:\n list_of_imgs_with_labels.append(img_full_file_name)\n list_of_corresponing_labels.append(corresponding_label[0])\n\n assert len(list_of_imgs_with_labels) == len(list_of_corresponing_labels)\n\n return list_of_imgs_with_labels, list_of_corresponing_labels","def get_corpus_filenames():\n corpus_file_list = []\n corpus_files = csv.reader(open('./gothic_text_data.csv'), delimiter=\",\", quotechar='\"')\n\n for row in corpus_files:\n if row[0] != \"Title\":\n corpus_file_list.append(row[14])\n return corpus_file_list","def load_data(filename):\n assert os.path.exists(filename)==True\n dat = scipy.io.loadmat(filename)\n inputs = dat['inputs']\n #print len(inputs)\n targets = dat['targets']\n #print len(targets)\n assert len(inputs)==len(targets)\n\n global alldata\n global indim \n global outdim\n\n indim = len(inputs[0])\n outdim = 1\n #print indim\n alldata = ClassificationDataSet(indim, outdim, nb_classes = 8)\n alldata.setField('input',inputs)\n alldata.setField('target',targets)\n\n assert len(alldata['input'])==len(alldata['target'])\n print type(alldata)","def get_test_files(self):\n train_dir = os.path.join(self.data_dir, \"test_{}_new\".format(self.patient_no))\n filenames = os.listdir(train_dir)\n interm = ((os.path.splitext(f)[0].split(\"_\"), os.path.join(train_dir, f)) for f in filenames)\n return [(int(p[0][1]), int(p[0][2]), p[1]) for p in interm]","def read_metadata_mat_file(meta_mat):\n mat = loadmat(meta_mat, squeeze_me=True)\n synsets = mat['synsets']\n cost_matrix = mat['cost_matrix']\n new_dtype = numpy.dtype([\n ('ILSVRC2010_ID', numpy.int16),\n ('WNID', ('S', max(map(len, synsets['WNID'])))),\n ('wordnet_height', numpy.int8),\n ('gloss', ('S', max(map(len, synsets['gloss'])))),\n ('num_children', numpy.int8),\n ('words', ('S', max(map(len, synsets['words'])))),\n ('children', (numpy.int8, max(synsets['num_children']))),\n ('num_train_images', numpy.uint16)\n ])\n new_synsets = numpy.empty(synsets.shape, dtype=new_dtype)\n for attr in ['ILSVRC2010_ID', 'WNID', 'wordnet_height', 'gloss',\n 'num_children', 'words', 'num_train_images']:\n new_synsets[attr] = synsets[attr]\n children = [numpy.atleast_1d(ch) for ch in synsets['children']]\n padded_children = [\n numpy.concatenate((c,\n -numpy.ones(new_dtype['children'].shape[0] - len(c),\n dtype=numpy.int16)))\n for c in children\n ]\n new_synsets['children'] = padded_children\n return new_synsets, cost_matrix","def filenames(self):\n pass","def _compile_data(tmp_dir, datasets, filename):\n filename = os.path.join(tmp_dir, filename)\n with tf.gfile.GFile(filename + \".lang1\", mode=\"w\") as lang1_resfile:\n with tf.gfile.GFile(filename + \".lang2\", mode=\"w\") as lang2_resfile:\n for dataset in datasets:\n url = dataset[0]\n compressed_filename = os.path.basename(url)\n compressed_filepath = os.path.join(tmp_dir, compressed_filename)\n\n lang1_filename = dataset[0]\n lang2_filename = dataset[1]\n lang1_filepath = os.path.join(tmp_dir, lang1_filename)\n lang2_filepath = os.path.join(tmp_dir, lang2_filename)\n is_sgm = (lang1_filename.endswith(\"sgm\") and\n lang2_filename.endswith(\"sgm\"))\n\n return filename","def get_files(self):\n self.cursor.execute(self.__get_contest_query__())\n result = self.cursor.fetchall()\n with open(self.country+'.txt', 'w') as outfile:\n for image in result:\n img = WlmFile(image, self.country, outfile)\n img.save()","def datasets(self):\n pass"],"string":"[\n \"def matrices_names(self, folder=None):\\n if folder is None:\\n abs_path = os.path.abspath(os.path.dirname(sys.argv[0]))\\n folder = os.path.join(abs_path, 'matrix')\\n\\n matrix_name_x = \\\"%s_%s_%s_%s_x.txt\\\" % (\\n self.D, self.Rs, self.axe_X, self.FOV_img)\\n matrix_file_x = os.path.join(folder, matrix_name_x)\\n\\n matrix_name_y = \\\"%s_%s_%s_%s_y.txt\\\" % (\\n self.D, self.Rs, self.axe_X, self.FOV_img)\\n matrix_file_y = os.path.join(folder, matrix_name_y)\\n\\n return matrix_file_x, matrix_file_y\",\n \"def _get_subject_files(self):\\n from itertools import chain\\n\\n subjsf = fetch_one_file(self.ica_dir, self._subjects_fname)\\n mat_file = sio.loadmat(subjsf)['files']\\n return [f.strip() for f in list(chain.from_iterable(chain.from_iterable(chain.from_iterable(mat_file))))]\",\n \"def collect_mat_files(dpath,dname='LMD',didx=0):\\n #dnames = ['LMD','Ballroom']\\n #dname = dnames[didx]\\n return glob.glob(os.path.join(dpath, dname,'*.mat'))\",\n \"def get_feature_labels_files(dataset):\\n features = []\\n audio_labels = []\\n focal_labels = []\\n files = []\\n for frame in dataset:\\n files.append(frame[0])\\n features.append(frame[1][0].T)\\n if frame[1][1] is not None:\\n audio_labels.append(frame[1][1][0].T)\\n focal_labels.append(frame[1][1][1].T)\\n else:\\n audio_labels.append(None)\\n focal_labels.append(None)\\n features = np.expand_dims(np.asarray(features), 4)\\n audio_labels = np.asarray(audio_labels)\\n focal_labels = np.asarray(focal_labels)\\n return [features, audio_labels,focal_labels, files]\",\n \"def read_matricies():\\n\\tmatrix_arr = []\\n\\tcurr_dirpath = os.getcwd()\\n\\tfor subdir, dirs, files in os.walk(curr_dirpath + '/Example Matrices'):\\n\\t\\tfor curr_file in files:\\n\\t\\t\\tcurr_filepath = curr_dirpath + '/Example Matrices/' + curr_file\\n\\t\\t\\twith open(curr_filepath, 'r') as open_file:\\n\\t\\t\\t\\tfor line in open_file:\\n\\t\\t\\t\\t\\tif len(line) > 0:\\n\\t\\t\\t\\t\\t\\tcurr_matrix = np.matrix(line)\\n\\t\\t\\t\\t\\t\\tmatrix_arr.append(curr_matrix)\\n\\treturn matrix_arr\",\n \"def get_filenames(is_training, data_dir):\\n if is_training:\\n return [os.path.join(data_dir, 'LIP_train5.record')]\\n else:\\n return [os.path.join(data_dir, 'LIP_val5.record')]\",\n \"def _get_filenames():\\n src_dir = os.path.join(FLAGS.dataset_dir, FLAGS.src_dir)\\n filenames = [os.path.join(src_dir, f) for f in os.listdir(src_dir) if\\n f.endswith(\\\".tfrecord\\\") and\\n all([blackflag not in f for blackflag in TEMP_BLACK_LIST])]\\n shuffle(filenames)\\n return filenames\",\n \"def get_filenames_reid(is_training, data_dir):\\n if is_training:\\n return [os.path.join(data_dir, 'train-512-170.tfrecords')]\\n else:\\n return [os.path.join(data_dir, 'val-512-170.tfrecords')]\",\n \"def list_mat_files(glob_pat):\\n fnames = glob.glob(glob_pat)\\n #print len(fnames)\\n return fnames\",\n \"def get_atlas_names():\\n tar_path = os.path.join(get_data_dir(), 'atlas')\\n xml_names = get_file_names(tar_path,'.xml')\\n return xml_names\",\n \"def LoadTroikaDataFile(data_fl):\\n data = sp.io.loadmat(data_fl)['sig']\\n return data[2:]\",\n \"def get_filenames(is_training,datadir):\\n assert os.path.exists(datadir), (\\n 'Can not find data at given directory!!')\\n if(is_training):\\n labels = []\\n data_dir = []\\n with open('/home/qnie/PycharmProjects/ntumotion/training_protocol/fEDM_R_CS_trainimgs.txt') as f:\\n for line in f:\\n data_dir.append(datadir+line.strip())\\n f.close()\\n\\n with open('/home/qnie/PycharmProjects/ntumotion/training_protocol/fEDM_R_CS_trainlabels.txt') as f:\\n for line in f:\\n labels.append(int(line.strip()))\\n f.close()\\n else:\\n labels = []\\n data_dir = []\\n with open('/home/qnie/PycharmProjects/ntumotion/training_protocol/fEDM_R_CS_testimgs.txt') as f:\\n for line in f:\\n data_dir.append(datadir + line.strip())\\n f.close()\\n\\n with open('/home/qnie/PycharmProjects/ntumotion/training_protocol/fEDM_R_CS_testlabels.txt') as f:\\n for line in f:\\n labels.append(int(line.strip()))\\n f.close()\\n\\n return data_dir, labels\",\n \"def get_filenames(root_dir):\\n from pathlib import Path\\n\\n file_list = Path(root_dir).rglob('*featuresN.hdf5')\\n file_list = [str(file) for file in file_list]\\n\\n filenames = pd.DataFrame(file_list, columns=['file_name'])\\n filenames.insert(0, 'file_id', np.arange(len(file_list)))\\n\\n return filenames\",\n \"def get_filenames(is_training, data_dir):\\n\\n return [ os.path.join(data_dir, 'train_'+str(shard_id)+'.tfrecord') for shard_id in range(_NUM_SHARDS)]\",\n \"def get_train_files(self):\\n train_dir = os.path.join(self.data_dir, \\\"train_{}\\\".format(self.patient_no))\\n filenames = os.listdir(train_dir)\\n interm = ((os.path.splitext(f)[0].split(\\\"_\\\"), os.path.join(train_dir, f)) for f in filenames)\\n return [(int(p[0][0]), int(p[0][1]), int(p[0][2]), p[1]) for p in interm]\",\n \"def read_dataset_files(datasetid, clean_folder):\\n fnotu = datasetid + '.otu_table.clean.feather'\\n fnmeta = datasetid + '.metadata.clean.feather'\\n\\n df = feather.read_dataframe(os.path.join(clean_folder, fnotu))\\n # Feather format does not support index names, first column has index\\n df.index = df.iloc[:,0]\\n df = df.iloc[:, 1:]\\n\\n meta = feather.read_dataframe(os.path.join(clean_folder, fnmeta))\\n meta.index = meta.iloc[:, 0]\\n meta = meta.iloc[:, 1:]\\n\\n ## Make sure sample names are strings\\n if df.index.dtype != 'O':\\n df.index = pd.read_csv(os.path.join(clean_folder, fnotu), sep='\\\\t', dtype=str).iloc[:,0]\\n\\n if meta.index.dtype != 'O':\\n meta.index = pd.read_csv(os.path.join(clean_folder, fnmeta), sep='\\\\t', dtype=str).iloc[:,0]\\n\\n return df, meta\",\n \"def read_dataset_v1():\\n path = load_config()\\n T = feather.read_dataframe(path['data_dir'] / 'T_dat.feather')\\n E = feather.read_dataframe(path['data_dir'] / 'E_dat.feather')\\n M = feather.read_dataframe(path['data_dir'] / 'Meta.feather')\\n data = sio.loadmat(path['data_dir'] / 'highvar_genes.mat', squeeze_me=True)\\n return T, E, M, data\",\n \"def raw_file_names(self):\\n return self.raw_file_names_3d\",\n \"def gen_datafiles():\\n\\tnum_reads = 10000\\n\\tnum_samples = 100\\n\\tgen_sequences('hg38.fa', num_reads, num_samples, 1, 'hg38_train.txt')\\n\\tgen_sequences('HIV-1.fasta', num_reads, num_samples, 0, 'HIV-1_train.txt')\\n\\tgen_sequences('hg38.fa', num_reads, num_samples, 1, 'hg38_test.txt')\\n\\tgen_sequences('HIV-1.fasta', num_reads, num_samples, 0, 'HIV-1_test.txt')\",\n \"def get_filenames():\\r\\n datadir = \\\"./phase3_data/\\\"\\r\\n samples = os.listdir(datadir)\\r\\n all_files = []\\r\\n for i in range(len(samples)):\\r\\n sampfiles = []\\r\\n datadir = \\\"./phase3_data/\\\" + samples[i]\\r\\n files = os.listdir(datadir)\\r\\n for file in files:\\r\\n if file.endswith(\\\".bin\\\"):\\r\\n sampfiles += [file]\\r\\n all_files += [sampfiles]\\r\\n return samples, all_files\",\n \"def return_file_read(_):\\n return [\\\"scorevideo LOG\\\", \\\"File: log.mat\\\"]\",\n \"def get_images_and_labels(tampered_path, authentic_path):\\n tampered_dir = tampered_path\\n authentic_dir = authentic_path\\n images = {}\\n for im in glob.glob(authentic_dir):\\n images[im] = {}\\n images[im]['mat'] = cv2.imread(im)\\n images[im]['label'] = 0\\n for im in glob.glob(tampered_dir):\\n images[im] = {}\\n images[im]['mat'] = cv2.imread(im)\\n images[im]['label'] = 1\\n return images\",\n \"def files():\\r\\n fn=pd.read_csv(request.files.get('fnm'))\\r\\n scaling = scaler.transform(fn)\\r\\n prediction = classifier.predict(scaling)\\r\\n return 'Predictions'+ str(list(prediction))\",\n \"def get_filenames(self):\\n return [doc['filename'] for doc in self.vocab]\",\n \"def img_filenames(self, matricule):\\n proj, sid = next((proj, proj.Matricule(matricule).to('AmcStudentId'))\\n for proj in self.projects_by_serie.values()\\n if proj.Matricule(matricule).exists('AmcStudentId'))\\n return [\\n (int(num), filename.replace('%PROJET', proj.path))\\n for num, filename in proj.dbs['capture'].execute('select page, src from capture_page where student=? order by page', [sid])\\n ]\",\n \"def getFilePaths():\\n \\n image_dir = r'/hpc/wfok007/mpi_heart/Training Set'\\n mask_paths = []\\n image_paths = []\\n for root, dirs, files in os.walk(image_dir, topdown=False):\\n for name in files:\\n if name == 'laendo.nrrd':\\n mask_paths.append(os.path.join(root, name))\\n elif name == 'lgemri.nrrd':\\n image_paths.append(os.path.join(root, name))\\n else:\\n print ('%s is unknown' %name)\\n return mask_paths, image_paths\",\n \"def inputFiles(self):\\n return (self.matrixFile,)\",\n \"def get_filename_data_readers(image_ids_file, get_labels=False,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tx_jpg_dir=None, y_png_dir=None):\\n\\tx_jpg_dir = x_jpg_dir or os.path.join(FLAGS.data_dir, 'images')\\n\\ty_png_dir = y_png_dir or os.path.join(FLAGS.data_dir, 'tf_segmentation')\\n\\t# TODO(student): Write code.\\n\\n\\tlines_dataset = tf.data.TextLineDataset(image_ids_file)\\n\\timages_dataset = lines_dataset.map(lambda x: x_jpg_dir + os.path.sep + x + '.jpg')\\n\\tif get_labels:\\n\\t\\tlabels_dataset = lines_dataset.map(lambda x: y_png_dir + os.path.sep + x + '.png')\\n\\t\\treturn images_dataset, labels_dataset\\n\\telse:\\n\\t\\treturn images_dataset\",\n \"def load_data():\\n\\n training_files_dir = \\\"digits/trainingDigits\\\"\\n training_files = os.listdir(training_files_dir)\\n file_num = len(training_files)\\n hw_labels = []\\n\\n training_mat = zeros((file_num, 32 * 32))\\n for i in xrange(file_num):\\n filename = training_files[i]\\n file_label = int((filename.split(\\\".\\\")[0]).split(\\\"_\\\")[0])\\n hw_labels.append(file_label)\\n training_mat[i, :] = img2vector(training_files_dir + '/' + filename)\\n\\n return training_mat, hw_labels\",\n \"def get_data_path():\\n up_folder = os.path.abspath(os.path.join(ROOT_DIR, '..'))\\n img_folder = os.path.join(up_folder, 'data_set', 'XX-ImageLabel', 'train_data_416')\\n img_file = os.path.join(DATA_DIR, \\\"t_img_tags_train.txt\\\") # 数据类别\\n return img_folder, img_file\",\n \"def get_filenames(self):\\n if self.mode == tf.estimator.ModeKeys.TRAIN:\\n lookup_name = 'train'\\n elif self.mode == tf.estimator.ModeKeys.EVAL:\\n lookup_name = 'validation'\\n elif self.mode == tf.estimator.ModeKeys.PREDICT:\\n lookup_name = self.predict_split\\n filenames = tf.gfile.Glob(\\n os.path.join(self.data_dir, '{}-*-of-*'.format(lookup_name)))\\n if tf.estimator.ModeKeys.PREDICT:\\n # Sort so that TFRecords will be read out deterministically.\\n filenames = sorted(filenames)\\n return filenames\",\n \"def get_filenames(self):\\n if self.mode == tf.estimator.ModeKeys.TRAIN:\\n lookup_name = 'train'\\n elif self.mode == tf.estimator.ModeKeys.EVAL:\\n lookup_name = 'validation'\\n elif self.mode == tf.estimator.ModeKeys.PREDICT:\\n lookup_name = self.predict_split\\n filenames = tf.gfile.Glob(\\n os.path.join(self.data_dir, '{}-*-of-*'.format(lookup_name)))\\n if tf.estimator.ModeKeys.PREDICT:\\n # Sort so that TFRecords will be read out deterministically.\\n filenames = sorted(filenames)\\n return filenames\",\n \"def import_data(hdfile, didx=0, dpath=BASE_PATH, PASS=False, dname='LMD'):\\n dset = Dataset(hdfile)\\n \\n genres = {}\\n for f in collect_mat_files(dpath,dname, didx):\\n data = loadmat(f)\\n g = data['genre'][0]\\n print f\\n if not g in genres:\\n genres[g] = len(genres)\\n \\n if not PASS:\\n x = data['features'].T\\n dset.add_data(X=[x],y=[genres[g]],\\n metadata=[{'filename':os.path.split(f)[-1]}])\\n \\n return genres\",\n \"def gather_dataset_names(path_to_files, project_name, suffix):\\r\\n species_trees_list = list_files_in_given_folder(path_to_files)\\r\\n dataset_names = extract_dataset_names(species_trees_list, project_name, suffix)\\r\\n return dataset_names\",\n \"def data_set_maker():\\n\\n # crate a folder in your code directory and name it: \\\"files\\\". put the .npy files iside that folder\\n path = os.getcwd() # reads the current path\\n x_train = np.load(path + '/files/tinyX.npy', 'r') # reads the input file\\n y_train = np.load(path + '/files/tinyY.npy', 'r') # reads the input file\\n x_test = np.load(path + '/files/tinyX_test.npy', 'r') # reads the input file\\n x_train, y_train = shuffle(x_train, y_train)\\n\\n return x_train, y_train, x_test\",\n \"def getTiffAsMatrix(kv):\\n file_name = kv[0].split('/')[-1]\\n fbinary = kv[1]\\n tiffmat = getOrthoTif(fbinary)\\n return (file_name,tiffmat)\",\n \"def _get_file_paths(self):\\n return [os.path.join(self.path, self.mode, 'waveforms', file_name + '.npy') for file_name in self.file_names]\",\n \"def read_file_names(self):\\n files_BIDMC = os.listdir(self.root_dir_BIDMC)\\n masks_BIDMC = os.listdir(self.seg_dir_BIDMC)\\n files_HK = os.listdir(self.root_dir_HK)\\n masks_HK = os.listdir(self.seg_dir_HK)\\n files_I2CVB = os.listdir(self.root_dir_I2CVB)\\n masks_I2CVB = os.listdir(self.seg_dir_I2CVB)\\n files_ISBI = os.listdir(self.root_dir_ISBI)\\n masks_ISBI = os.listdir(self.seg_dir_ISBI)\\n files_ISBI_15 = os.listdir(self.root_dir_ISBI_15)\\n masks_ISBI_15 = os.listdir(self.seg_dir_ISBI_15)\\n files_UCL = os.listdir(self.root_dir_UCL)\\n masks_UCL = os.listdir(self.seg_dir_UCL)\\n site_files = [files_BIDMC, files_HK, files_I2CVB, files_ISBI, files_ISBI_15, files_UCL]\\n site_masks = [masks_BIDMC, masks_HK, masks_I2CVB, masks_ISBI, masks_ISBI_15, masks_UCL]\\n return site_files, site_masks\",\n \"def read_fn(file_references, mode, params=None):\\r\\n print('Reading the dataset from Datalakestore (2mm NIfTI images)....')\\r\\n\\r\\n def _augment(img):\\r\\n \\\"\\\"\\\"An image augmentation function\\\"\\\"\\\"\\r\\n return flip(img, axis=2)\\r\\n\\r\\n image_array = []\\r\\n label_array = []\\r\\n for f in file_references:\\r\\n subject_id = f[0]\\r\\n\\r\\n # Read the image nii with sitk\\r\\n ##t1_fn = os.path.join(data_path, '{}/T1_2mm.nii.gz'.format(subject_id))\\r\\n ##t1 = sitk.GetArrayFromImage(sitk.ReadImage(str(t1_fn)))\\r\\n t1_fn = os.path.join(data_path, '{}/T1_2mm.nii.gz'.format(subject_id))\\r\\n print(t1_fn)\\r\\n #with adlsFileSystemClient.open(t1_fn, 'rb') as f:\\r\\n # img = sitk.ReadImage(str(f))\\r\\n # sitk::ERROR: The file \\\"<ADL file: /clusters/DLTK_IXI_Dataset/2mm/IXI012/T1_2mm.nii.gz>\\\" does not exist.\\r\\n # sitk seems only read from local path....how to read from remote path????????\\r\\n # for short term download to local path\\r\\n # rpath is datalakestore, lpath is local file path both have the same root structure '/clusters/DLTK_IXI_Dataset/'\\r\\n multithread.ADLDownloader(adlsFileSystemClient, rpath=t1_fn, lpath=t1_fn, nthreads=5, chunksize=2**24, overwrite=True)\\r\\n img = sitk.ReadImage(str(t1_fn))\\r\\n # you need http://imagej.net/Fiji#Downloads app to show the img. More discussion and instruction: https://stackoverflow.com/questions/45682319/simpleitk-show-generates-error-in-imagej-on-linux\\r\\n ##sitk.Show(img)\\r\\n t1 = sitk.GetArrayFromImage(img)\\r\\n\\r\\n # Normalise volume image\\r\\n t1 = whitening(t1)\\r\\n images = np.expand_dims(t1, axis=-1).astype(np.float32)\\r\\n\\r\\n if mode == tf.estimator.ModeKeys.PREDICT:\\r\\n yield {'features': {'x': images}, 'img_id': subject_id}\\r\\n print('read_fn Predict')\\r\\n\\r\\n # Parse the sex classes from the file_references [1,2] and shift them\\r\\n # to [0,1]\\r\\n sex = np.int(f[1]) - 1\\r\\n y = np.expand_dims(sex, axis=-1).astype(np.int32)\\r\\n\\r\\n # Augment if used in training mode\\r\\n if mode == tf.estimator.ModeKeys.TRAIN:\\r\\n images = _augment(images)\\r\\n print('read_fn Train')\\r\\n # Check if the reader is supposed to return training examples or full images\\r\\n if params['extract_examples']:\\r\\n #print('read_fn params extract_examples')\\r\\n images = extract_random_example_array(\\r\\n image_list=images,\\r\\n example_size=params['example_size'],\\r\\n n_examples=params['n_examples'])\\r\\n for e in range(params['n_examples']):\\r\\n #print ('e: ', e)\\r\\n## yield {'features': {'x': images[e].astype(np.float32)},\\r\\n## 'labels': {'y': y.astype(np.float32)},\\r\\n## 'img_id': subject_id}\\r\\n image_array.append(images[e].astype(np.float32))\\r\\n label_array.append(y.astype(np.int32))\\r\\n else:\\r\\n print('read_fn params yield last')\\r\\n## yield {'features': {'x': images},\\r\\n## 'labels': {'y': y.astype(np.float32)},\\r\\n## 'img_id': subject_id}\\r\\n image_array.append(images)\\r\\n label_array.append(y.astype(np.int32))\\r\\n\\r\\n print(\\\"read_fn yield output_array with image shape = \\\", images.shape, \\\"label shape = \\\", y.shape)\\r\\n yield {'x': np.array(image_array), 'y': np.array(label_array)}\",\n \"def get_data(path):\\n all_images_as_array=[]\\n label=[]\\n for filename in os.listdir(path):\\n try:\\n if re.match(r'positive',filename):\\n label.append(1)\\n else:\\n label.append(0)\\n img=cv2.imread(path + filename)\\n (b, g, r)=cv2.split(img)\\n img=cv2.merge([r,g,b])\\n np_array = np.asarray(img)\\n l,b,c = np_array.shape\\n np_array = np_array.reshape(l*b*c,)\\n all_images_as_array.append(np_array)\\n except:\\n continue\\n return np.array(all_images_as_array), np.array(label)\",\n \"def get_filenames(is_training, data_dir):\\n if is_training:\\n return [\\n os.path.join(data_dir, 'train-%05d-of-01024' % i)\\n for i in range(_NUM_TRAIN_FILES)]\\n else:\\n return [\\n os.path.join(data_dir, 'validation-%05d-of-00128' % i)\\n for i in range(_NUM_VAL_FILES)]\",\n \"def read_dataset(path_to_dataset_folder, index_filename):\\n ###############################################################\\n # Fill your code in this function\\n ###############################################################\\n # Hint: open(path_to_dataset_folder+'/'+index_filename,'r')\\n with open(path_to_dataset_folder + '/' + index_filename, 'r') as index_file:\\n lines = index_file.readlines()\\n txt_paths = {}\\n for line in lines:\\n txt_path = line.split()\\n txt_paths[txt_path[1]] = txt_path[0]\\n\\n A = []\\n T = []\\n for sample_file, label in txt_paths.items():\\n A_16dim = []\\n with open(path_to_dataset_folder + '/' + sample_file, 'r') as dim_values:\\n lines = dim_values.readlines()\\n for line in lines:\\n dim_value = line.split()\\n A_helper = [1]\\n for element in dim_value:\\n A_helper.append(float(element))\\n A.append(A_helper)\\n label = int(label)\\n T_helper = [label]\\n T.append(T_helper)\\n A = np.array(A)\\n T = np.array(T)\\n return A, T\",\n \"def list_datasets():\\n return METADATA.keys()\",\n \"def list_dataset(filename, type = 'roi'):\\n import os\\n import numpy as np\\n\\n root,camera_name,dataset_name,chunk,extension = split_raw_filename(filename)\\n lst_dir = os.listdir(root)\\n lst_dataset = []\\n lst_order = []\\n for item in lst_dir:\\n if item.find(camera_name+'_'+dataset_name + '_') != -1:\\n rt,camera_name,dataset_name,chunk,extension = split_raw_filename(item)\\n if extension == f\\\"{type}.hdf5\\\":\\n lst_dataset.append(os.path.join(root,item))\\n lst_order.append(int(chunk))\\n lst_sorted = np.argsort(np.array(lst_order))\\n return list(np.array(lst_dataset)[lst_sorted])\",\n \"def load_data(animal, selection, verbose=False):\\r\\n\\tpath_raw = os.path.join(paths.path2Data, animal, 'Raw Data')\\r\\n\\t\\r\\n\\traw_paths = [os.path.join(path_raw, file) for file in ['ROIBinmaps_{0}.mat'.format(animal), 'ALLDFF.mat', 'ALLBEHmatrix.mat', 'ALLf0.mat']]\\r\\n\\r\\n\\tmeta_df = pd.read_csv(os.path.join(path_raw, 'meta_df.csv'), index_col=0)\\r\\n\\t\\r\\n\\t# Load matrices as dictionnary {name: matrix_values}\\r\\n\\troi_file, raw_mat, raw_beh, f0 = list(map(loadmat, raw_paths))\\r\\n\\t\\r\\n\\t# Indexing data of interest\\r\\n\\troi_tensor = roi_file['ROIBinmaps']\\r\\n\\r\\n\\t# Remove the first second of acquisition\\r\\n\\tacti = raw_mat['ALLDFF'][:,15:,:]\\r\\n\\t\\r\\n\\tf0 = f0['F0ALL']\\r\\n\\r\\n\\tif verbose: \\r\\n\\t\\tN, T, K = acti.shape\\r\\n\\t\\tprint('Data contain activity of', N, 'ROI, on a time scale of', T/15, 'seconds, during', K, 'trials')\\r\\n\\r\\n\\treturn meta_df, roi_tensor, acti, f0\",\n \"def get_datasets(data):\\n train_dataset, test_dataset = None, None\\n data_dir = '../data'\\n\\n if data == 'fmnist':\\n transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean=[0.2860], std=[0.3530])])\\n train_dataset = datasets.FashionMNIST(data_dir, train=True, download=True, transform=transform)\\n test_dataset = datasets.FashionMNIST(data_dir, train=False, download=True, transform=transform)\\n \\n elif data == 'fedemnist':\\n train_dir = '../data/Fed_EMNIST/fed_emnist_all_trainset.pt'\\n test_dir = '../data/Fed_EMNIST/fed_emnist_all_valset.pt'\\n train_dataset = torch.load(train_dir)\\n test_dataset = torch.load(test_dir) \\n \\n elif data == 'cifar10':\\n transform_train = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),\\n ])\\n transform_test = transforms.Compose([\\n transforms.ToTensor(),\\n transforms.Normalize(mean=(0.4914, 0.4822, 0.4465), std=(0.2023, 0.1994, 0.2010)),\\n ])\\n train_dataset = datasets.CIFAR10(data_dir, train=True, download=True, transform=transform_train)\\n test_dataset = datasets.CIFAR10(data_dir, train=False, download=True, transform=transform_test)\\n train_dataset.targets, test_dataset.targets = torch.LongTensor(train_dataset.targets), torch.LongTensor(test_dataset.targets) \\n \\n return train_dataset, test_dataset\",\n \"def read_mat_file(filename):\\n mat_contents = sio.loadmat(filename)\\n image_data = mat_contents['image']['img'][0, 0]\\n return image_data\",\n \"def get_memes_data(path):\\n data = load_files(path)\\n memes = np.array(data['filenames'])\\n return memes\",\n \"def _get_dataset_contents(self,\\n dataset_root_path: str,\\n property_alias: str) -> Tuple[np.ndarray, np.ndarray, List[int], List[str]]:\\n cur_dir = os.getcwd()\\n os.chdir(dataset_root_path) # the parent folder with sub-folders\\n\\n list_fams, no_imgs, num_samples = self._get_labels_info(property_alias)\\n\\n y, indexes = self._fetch_labels(list_fams, no_imgs, num_samples)\\n X, samples_names = self._get_X_and_names(list_fams, num_samples, property_alias)\\n\\n os.chdir(cur_dir)\\n\\n return X, y, indexes, samples_names\",\n \"def samples(self):\\n return glob.glob(os.path.join(self.production.rundir, \\\"extrinsic_posterior_samples.dat\\\"))\",\n \"def get_test_files(self):\\n test_images = np.array(\\n glob('/media/data_cifs/pytorch_projects/datasets/BSDS500_crops/data/images/test_nocrop/*.jpg'))\\n test_labels = np.array(\\n [x.replace('images', 'groundTruth').replace('.jpg', '.npy') for x in test_images])\\n test_labels = np.array(\\n [np.load(x) for x in test_labels])\\n keep_idx = np.array([True if x.shape[0] > x.shape[1] else False for x in test_labels])\\n test_images = test_images[keep_idx]\\n return test_images\",\n \"def get_filenames(mode, data_dir):\\n if mode == 'train':\\n return [os.path.join(data_dir, 'encoder.train.input'), os.path.join(data_dir, 'encoder.train.target'),\\n os.path.join(data_dir, 'decoder.train.target')]\\n else:\\n return [os.path.join(data_dir, 'encoder.test.input'), os.path.join(data_dir, 'encoder.test.target'),\\n os.path.join(data_dir, 'decoder.test.target')]\",\n \"def files_debug(dirfiles):\\r\\n\\r\\n files_path = {}\\r\\n \\r\\n normal_folder = [\\\"K002\\\"]\\r\\n OR_folder = [\\\"KA01\\\"]\\r\\n IR_folder = [\\\"KI01\\\"]\\r\\n MIX_folder = [\\\"KB23\\\"] # VERIFICAR\\r\\n\\r\\n settings_files = [\\\"N15_M07_F10_\\\", \\\"N09_M07_F10_\\\", \\\"N15_M01_F10_\\\", \\\"N15_M07_F04_\\\"]\\r\\n\\r\\n n = 20\\r\\n\\r\\n # Normal\\r\\n for folder in normal_folder:\\r\\n for idx, setting in enumerate(settings_files):\\r\\n for i in range(1, n+1):\\r\\n key = \\\"Normal_\\\" + folder + \\\"_\\\" + str(idx) + \\\"_\\\" + str(i)\\r\\n files_path[key] = os.path.join(dirfiles, folder, setting + folder +\\r\\n \\\"_\\\" + str(i) + \\\".mat\\\")\\r\\n\\r\\n # OR\\r\\n for folder in OR_folder:\\r\\n for idx, setting in enumerate(settings_files):\\r\\n for i in range(1, n+1):\\r\\n key = \\\"OR_\\\" + folder + \\\"_\\\" + str(idx) + \\\"_\\\" + str(i)\\r\\n files_path[key] = os.path.join(dirfiles, folder, setting + folder +\\r\\n \\\"_\\\" + str(i) + \\\".mat\\\")\\r\\n\\r\\n # IR\\r\\n for folder in IR_folder:\\r\\n for idx, setting in enumerate(settings_files):\\r\\n for i in range(1, n+1):\\r\\n key = \\\"IR_\\\" + folder + \\\"_\\\" + str(idx) + \\\"_\\\" + str(i)\\r\\n files_path[key] = os.path.join(dirfiles, folder, setting + folder +\\r\\n \\\"_\\\" + str(i) + \\\".mat\\\")\\r\\n\\r\\n return files_path\",\n \"def load_labeled_data():\\n\\n images = []\\n labels = []\\n\\n for i in range(1, 10):\\n path = (\\\"selflabeled\\\", str(i), \\\"*.jpg\\\")\\n filenames = glob.glob(\\\"/\\\".join(path))\\n images_one_type = [cv2.imread(img) for img in filenames]\\n labels_one_type = [i] * len(images_one_type)\\n images += images_one_type\\n labels += labels_one_type\\n\\n return images, labels\",\n \"def get_train_data(data, lang):\\n train_files = open(os.path.join('traintestsplit', lang+'.trainlist')).read().split()\\n return [data[lang][filename+'.npytxt'] for filename in train_files]\",\n \"def readmnist(dataset = \\\"training\\\", path = \\\".\\\"):\\n\\n if dataset is \\\"training\\\":\\n fname_img = os.path.join(path, 'train-images.idx3-ubyte')\\n fname_lbl = os.path.join(path, 'train-labels.idx1-ubyte')\\n elif dataset is \\\"testing\\\":\\n fname_img = os.path.join(path, 't10k-images.idx3-ubyte')\\n fname_lbl = os.path.join(path, 't10k-labels.idx1-ubyte')\\n # else:\\n # raise ValueError, \\\"dataset must be 'testing' or 'training'\\\"\\n\\n # Load everything in some numpy arrays\\n with open(fname_lbl, 'rb') as flbl:\\n magic, num = struct.unpack(\\\">II\\\", flbl.read(8))\\n lbl = np.fromfile(flbl, dtype=np.int8)\\n\\n with open(fname_img, 'rb') as fimg:\\n magic, num, rows, cols = struct.unpack(\\\">IIII\\\", fimg.read(16))\\n img = np.fromfile(fimg, dtype=np.uint8).reshape(len(lbl), rows, cols)\\n\\n get_img = lambda idx: (lbl[idx], img[idx])\\n\\n # Create an iterator which returns each image in turn\\n for i in xrange(len(lbl)):\\n yield get_img(i)\",\n \"def KittiTestDataset(test_root_path):\\n \\n names = os.listdir(test_root_path)\\n dataset = [[os.path.join(test_root_path, name)] for name in names]\\n \\n return dataset\",\n \"def load_matrices(index, field):\\n cov_root = os.path.join(file_root, 'CovMatricesAll/')\\n suffix2 = '_n%d_m%d_%s%s_%s.txt' % (n, m, field, field, index)\\n suffix3 = '_n%d_m%d_%s,%s%s_%s.txt' % (n, m, field, field, field, index)\\n suffix4 = '_n%d_m%d_%s%s,%s%s_%s.txt' % (n, m, field, field, field, field, index)\\n c2 = np.diag(np.loadtxt(cov_root + 'c2' + suffix2)[skip_bins:])\\n c3 = np.loadtxt(cov_root + 'c3' + suffix3)[skip_bins:, skip_bins:]\\n c4 = np.loadtxt(cov_root + 'c4' + suffix4)[skip_bins:, skip_bins:]\\n\\n # Now symmetrize and return matrices\\n return c2, 0.5*(c3+c3.T), 0.5*(c4+c4.T)\",\n \"def gene_txt_of_load(dirname):\\n str_list=[]\\n list_name=[]\\n print 'Yolo Debut'\\n for file in os.listdir(dirname):\\n if file.endswith(\\\".npy\\\"):\\n str_list.append(file[:-4]+'=np.load(dirname+'+'\\\\\\\"/\\\\\\\"'+'+\\\\\\\"'+file+'\\\\\\\")')\\n list_name.append(file[:-4])\\n print '\\\\n'.join(str_list)\\n print ','.join(list_name)\\n return str_list\",\n \"def write_all_patients():\\n\\n data_dir = sys.argv[1]\\n output_dir = sys.argv[2]\\n\\n imgs, i_msks, o_msks = load_all_patients(data_dir=data_dir)\\n\\n for idx, array in enumerate(imgs):\\n np.save(output_dir+'/img_'+str(idx), array)\\n for idx, array in enumerate(i_msks):\\n np.save(output_dir+'/i_msk_'+str(idx), array)\\n for idx, array in enumerate(o_msks):\\n np.save(output_dir + '/o_msk_' + str(idx), array)\\n\\n return None\",\n \"def load_matrices(self):\\n self.wine_matrix = np.array(self.parse_file_into_array('winequality-red.csv', ';'))\\n self.cancer_matrix = np.array(self.parse_file_into_array('breast-cancer-wisconsin.data', ','))\",\n \"def get_labels():\\n return [name for name in os.listdir(os.getcwd() + '/assets/images') if name != 'test']\",\n \"def get_torch_dataset_images_labels(data_dir):\\r\\n\\r\\n # Transforms for testing sets\\r\\n test_transforms = transforms.Compose([transforms.Resize(255),\\r\\n transforms.CenterCrop(224),\\r\\n transforms.ToTensor(),\\r\\n transforms.Normalize((0.485, 0.456, 0.406),\\r\\n (0.229, 0.224, 0.225))])\\r\\n\\r\\n # Definition of testing datasets using ImageFolder\\r\\n test_datasets = datasets.ImageFolder(data_dir, transform=test_transforms)\\r\\n\\r\\n return test_datasets.imgs\",\n \"def datasets(self):\\n return [Dataset.GWAS_CATALOG, Dataset.CLINVAR, Dataset.EFO]\",\n \"def getAllFileNames(self):\\n #images = [\\\"image1.jpg\\\",\\\"image2.jpg\\\",\\\"image3.jpg\\\"]\\n \\n os.chdir(self.dataDir)\\n filenames = glob.glob(\\\"*.*\\\")\\n filenames.sort() \\n return filenames\",\n \"def get_dataset_files(dataset_info, mode, root):\\n basepath = dataset_info.basepath\\n base = os.path.join(root, basepath, mode)\\n\\n # usually of form '{}-of-{}.tfrecord'\\n files = sorted(os.listdir(base))\\n\\n return [os.path.join(base, file) for file in files]\",\n \"def get_path_and_label(self):\\n DATA_SIZE = 700\\n category = os.listdir(os.path.join(self.root, 'NWPU-RESISC45'))\\n image_path = []\\n label = []\\n for cat in category:\\n cat_enc = self.class_enc[cat]\\n label += [cat_enc] * DATA_SIZE\\n for num in range(1, DATA_SIZE+1):\\n filename = cat + '_' + str(num).zfill(3) + '.jpg'\\n image_path += [os.path.join(self.root,\\n 'NWPU-RESISC45', cat, filename)]\\n df = pd.DataFrame({'image': image_path, 'label': label})\\n\\n return df\",\n \"def get_filename(images):\\n image_file = {}\\n for image in images:\\n image_file[image['id']] = os.path.join('train2017', image['file_name'])\\n return image_file\",\n \"def get_path_and_label(self):\\n image_path = []\\n label = []\\n\\n for image in glob.glob(os.path.join(self.root,self.data_mode,'*_photo.png')):\\n image_path.append(image)\\n \\n for mask in glob.glob(os.path.join(self.root,self.data_mode,'*_mask.png')):\\n label.append(mask)\\n\\n df = pd.DataFrame({'image': sorted(image_path), 'label': sorted(label)})\\n\\n return df\",\n \"def explore_data():\\n labels = [\\\"vehicles\\\", \\\"non-vehicles\\\"]\\n labelmap = {0: \\\"vehicles\\\", 1: \\\"non-vehicles\\\"}\\n vehicles_glob = os.path.join(data_dir, \\\"vehicles\\\", \\\"**\\\", \\\"*.png\\\")\\n nonvehicles_glob = os.path.join(data_dir, \\\"non-vehicles\\\", \\\"**\\\", \\\"*.png\\\")\\n class_fnames = [\\n glob.glob(vehicles_glob, recursive = True),\\n glob.glob(nonvehicles_glob, recursive = True)]\\n n_samples = [len(fnames) for fnames in class_fnames]\\n shapes = []\\n samples = []\\n print(table_format([\\\"label\\\", \\\"size\\\", \\\"shape\\\"], header = True))\\n for label, fnames in enumerate(class_fnames):\\n indices = np.random.choice(len(fnames), 4*10, replace = False)\\n for i in indices:\\n fname = fnames[i]\\n img = cv2.imread(fname)\\n samples.append(img)\\n shape = img.shape\\n shapes.append(shape)\\n print(table_format([labels[label], n_samples[label], shapes[label]]))\\n\\n samples = np.stack(samples)\\n samples = tile(samples, 2*4, 10)\\n cv2.imwrite(os.path.join(out_dir, \\\"datasamples.png\\\"), samples)\\n\\n return class_fnames, labelmap\",\n \"def raw_file_names_3d(self):\\n return [self.id_to_relative_raw_path(x) for x in self.cloud_ids]\",\n \"def _setup_data_filenames(self):\\n\\n # read in filenames of training data(poses, images, labels)\\n logging.info('Reading filenames')\\n all_filenames = os.listdir(self.data_dir)\\n if self.image_mode== ImageMode.BINARY:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.binary_im_tensor_template) > -1]\\n elif self.image_mode== ImageMode.DEPTH:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tensor_template) > -1]\\n elif self.image_mode== ImageMode.BINARY_TF:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.binary_im_tf_tensor_template) > -1]\\n elif self.image_mode== ImageMode.COLOR_TF:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.color_im_tf_tensor_template) > -1]\\n elif self.image_mode== ImageMode.GRAY_TF:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.gray_im_tf_tensor_template) > -1]\\n elif self.image_mode== ImageMode.DEPTH_TF:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tf_tensor_template) > -1]\\n elif self.image_mode== ImageMode.DEPTH_TF_TABLE:\\n self.im_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.depth_im_tf_table_tensor_template) > -1]\\n else:\\n raise ValueError('Image mode %s not supported.' %(self.image_mode))\\n\\n self.pose_filenames = [f for f in all_filenames if f.find(ImageFileTemplates.hand_poses_template) > -1]\\n self.label_filenames = [f for f in all_filenames if f.find(self.target_metric_name) > -1]\\n\\n self.im_filenames.sort(key = lambda x: int(x[-9:-4]))\\n self.pose_filenames.sort(key = lambda x: int(x[-9:-4]))\\n self.label_filenames.sort(key = lambda x: int(x[-9:-4]))\\n\\n # check that all file categories were found\\n if len(self.im_filenames) == 0 or len(self.label_filenames) == 0 or len(self.label_filenames) == 0:\\n raise ValueError('1 or more required training files could not be found')\",\n \"def load_data():\\n prefix = 'mnist_data/'\\n train_data = np.load(prefix + 'mnist_train_images.npy')\\n train_labels = np.load(prefix + 'mnist_train_labels.npy')\\n val_data = np.load(prefix + 'mnist_validation_images.npy')\\n val_labels = np.load(prefix + 'mnist_validation_labels.npy')\\n test_data = np.load(prefix + 'mnist_test_images.npy')\\n test_labels = np.load(prefix + 'mnist_test_labels.npy')\\n assert train_data.shape == (55000, 784) and train_labels.shape == (55000, 10)\\n assert val_data.shape == (5000, 784) and val_labels.shape == (5000, 10)\\n assert test_data.shape == (10000, 784) and test_labels.shape == (10000, 10)\\n return train_data, train_labels, val_data, val_labels, test_data, test_labels\",\n \"def label_names_file():\\n return tfds.core.tfds_path(_LABELS_FNAME)\",\n \"def read_models():\\n model_files_cvd = np.sort(glob.glob(\\\"./grad_results/cvd*N1024_f0003.npy\\\"))\\n model_files_mnist = np.sort(glob.glob(\\\"./grad_results/mnist*N25000_f02.npy\\\"))\\n\\n model_files_cvd = np.array([model_files_cvd[2], model_files_cvd[1], model_files_cvd[0]])\\n\\n results_cvd = []\\n results_mnist = []\\n\\n for filename in model_files_cvd:\\n results_cvd.append(np.load(filename))\\n \\n for filename in model_files_mnist:\\n results_mnist.append(np.load(filename))\\n\\n return np.array(results_mnist), np.array(results_cvd)\",\n \"def test_get_dataset_path(self) -> None:\\n framework = \\\"tensorflow\\\"\\n domain = \\\"image_recognition\\\"\\n result = get_dataset_path(framework, domain)\\n self.assertEqual(result, \\\"examples/test/dataset/imagenet\\\")\",\n \"def getDatasets(fileinformation):\\n filedata = pd.read_csv(fileinformation, sep=\\\"\\\\t\\\", header=None)\\n datalabels = list(filedata.iloc[:,0].values)\\n datafiles = list(filedata.iloc[:,1].values)\\n return datalabels, datafiles\",\n \"def get_data(folder):\\n X = []\\n y = []\\n for folderName in os.listdir(folder):\\n if not folderName.startswith('.'):\\n if folderName in ['NORMAL']:\\n label = 0\\n elif folderName in ['CNV']:\\n label = 1\\n elif folderName in ['DME']:\\n label = 2\\n elif folderName in ['DRUSEN']:\\n label = 3\\n else:\\n label = 4\\n for image_filename in tqdm(os.listdir(folder + folderName)):\\n img_file = cv2.imread(folder + folderName + '/' + image_filename)\\n if img_file is not None:\\n img_file = skimage.transform.resize(img_file, (imageSize, imageSize, 3))\\n img_arr = np.asarray(img_file)\\n X.append(img_arr)\\n y.append(label)\\n X = np.asarray(X)\\n y = np.asarray(y)\\n return X,y\",\n \"def get_filename_dataset(self, data_dir):\\n # Get filenames\\n data_dir = pathlib.Path(data_dir)\\n list_ds = tf.data.Dataset.list_files(str(data_dir / '*'))\\n\\n # Create data pre-processing functions\\n funcs = self._get_data_preprocessing_fns()\\n\\n # Get FAKE labeled dataset\\n ds = list_ds.map(funcs.process_img_path, num_parallel_calls=AUTOTUNE)\\n # Format conversion\\n ds = ds.map(funcs.convert_format, num_parallel_calls=AUTOTUNE)\\n # Resizing\\n ds = ds.map(funcs.resize, num_parallel_calls=AUTOTUNE)\\n\\n # Batch, prefetch\\n ds = ds.batch(1)\\n\\n return ds\",\n \"def get_data_files():\\n data_files = []\\n\\n # Walk through the data directory, adding all files\\n data_generator = os.walk('pypeit/data')\\n for path, directories, files in data_generator:\\n for f in files:\\n data_path = '/'.join(path.split('/')[1:])\\n data_files.append(os.path.join(data_path, f))\\n\\n # Add pipeline and spectrograph settings\\n settings = glob.glob('pypeit/settings/settings.*')\\n settings = ['/'.join(path.split('/')[1:]) for path in settings]\\n data_files.extend(settings)\\n\\n return data_files\",\n \"def read_state_matrices():\\r\\n drum_mats = glob.glob('./Melody_Bass_Data/*_bass.txt')\\r\\n melody_mats = glob.glob('./Melody_Bass_Data/*_melody.txt')\\r\\n \\r\\n drum_states = []\\r\\n melody_states = []\\r\\n\\r\\n for drum_mat,melody_mat in zip(drum_mats[:20],melody_mats[:20]):\\r\\n temp= np.genfromtxt(drum_mat)\\r\\n drum_states.append(temp)\\r\\n temp= np.genfromtxt(melody_mat)\\t\\r\\n melody_states.append(temp)\\r\\n \\r\\n return drum_states,melody_states\",\n \"def get_data(folder):\\n X = []\\n y = []\\n\\n for seismic_type in os.listdir(folder):\\n if not seismic_type.startswith('.'):\\n if seismic_type in ['Class1']:\\n label = '0'\\n else:\\n label = '1'\\n for image_filename in os.listdir(folder + seismic_type):\\n img_file = cv2.imread(folder + seismic_type + '/' + image_filename)\\n if img_file is not None:\\n # Downsample the image to 120, 160, 3\\n #img_file = scipy.misc.imresize(arr=img_file, size=(120, 160, 3))\\n img_arr = np.asarray(img_file)\\n # img_arr = image.img_to_array(img_arr)\\n X.append(img_arr)\\n y.append(label)\\n X = np.asarray(X)\\n y = np.asarray(y)\\n return X,y\",\n \"def get_spike_data():\\n neuron_spikes = []\\n first = 0\\n last = 0\\n for i, file in enumerate(os.listdir(\\\"\\\"\\\"/Users/markusekvall/Desktop/\\n final_entropy_model/Spike_trains\\\"\\\"\\\")):\\n if file.endswith(\\\".mat\\\"):\\n if file[0] == \\\".\\\":\\n continue\\n else:\\n x = sio.loadmat(os.path.join(\\\"./Spike_trains\\\", file))\\n cluster_class = x[\\\"cluster_class\\\"]\\n # Set to ==2 if you want the second cluster\\n idx = [cluster_class[:, 0] == 1]\\n spike = cluster_class[idx[0], 1]\\n if np.size(spike) != 0:\\n if max(spike) > last:\\n last = max(spike)\\n if min(spike) > last:\\n first = min(spike)\\n neuron_spikes.append(spike)\\n return neuron_spikes, first, last\",\n \"def get_data(self):\\n\\n if not self.checked:\\n self.check_cache()\\n h5f = h5py.File(self.data_filename, 'r')\\n train_lbl = h5f['train_lbl'][:]\\n train_img = h5f['train_img'][:]\\n val_lbl = h5f['val_lbl'][:]\\n val_img = h5f['val_img'][:]\\n h5f.close()\\n return train_img, train_lbl, val_img, val_lbl\",\n \"def __get_dataset_name(self):\\n d = gdal.Open(self.fname)\\n # Get band metadata\\n b = d.GetRasterBand(1)\\n md = b.GetMetadata()\\n\\n if 'data_var' in md:\\n return md['data_var']\\n else:\\n fnames = d.GetFileList()\\n if len(fnames) > 2:\\n d = gdal.Open(fnames[1])\\n # Get band metadata\\n b = d.GetRasterBand(1)\\n md = b.GetMetadata()\\n if 'data_var' in md:\\n return md['data_var']\\n else:\\n return 'data'\\n else:\\n return 'data'\",\n \"def get_matrices(training_set_path):\\n if os.path.isfile(training_set_path):\\n X = HDF5Matrix(training_set_path, 'input/input')\\n y = HDF5Matrix(training_set_path, 'target/target')\\n y_seg = HDF5Matrix(training_set_path, 'seg_map/seg_map')\\n return X, y, y_seg\\n else:\\n raise Exception('Training set file not found.')\",\n \"def read_files_and_visualize(data):\\n\\n image = cv2.imread(data[0])\\n label = cv2.imread(data[1], 0)\\n name = data[1].split('/')[-1].split('.')[0]\\n obj_label = None\\n\\n if generator_options.save_label_preview:\\n obj_label = []\\n if os.path.isfile(data[2]):\\n with open(data[2], 'r') as f:\\n obj = csv.reader(f, delimiter=',')\\n for row in obj:\\n row = [int(r.split('.')[0]) if index != 0 else r\\n for index, r in enumerate(row)]\\n obj_label.append(row)\\n\\n else:\\n label_vals = np.unique(label)\\n for val in label_vals:\\n obj_label.append([_LABEL_DEF_FULL[val], 0, 0, 0, 0])\\n\\n save_visuals(image, label, obj_label, name)\",\n \"def load_data():\\n\\n print('Loading and Visualizing Data ...')\\n\\n file_name = path.join(getcwd(), 'ex3', 'src', 'data', 'ex3data1')\\n data = scipy.io.loadmat(file_name)\\n\\n # training data stored in arrays X, y\\n # y should be a row vector of labels\\n return data['X'], data['y'].T[0]\",\n \"def read_data_sets_label(data_dir, label):\\n train_data, test_data = read_data_sets(data_dir, one_hot=False)\\n train_mask = create_mask(train_data, label)\\n test_mask = create_mask(test_data, label)\\n return (train_data.images[train_mask], test_data.images[test_mask])\",\n \"def _get_all_files(self):\\n file_pattern = _FILE_PATTERN\\n file_pattern = os.path.join(self.dataset_dir,\\n file_pattern % self.split_name)\\n return tf.gfile.Glob(file_pattern)\",\n \"def import_func(path_):\\n\\n datasets_dic = {}\\n\\n for dataset_path in path_:\\n # Parse labels from filenames\\n dataset_label = os.path.split(dataset_path)[1].split('.')[0]\\n\\n # Read from csv to Pandas\\n dataset = pd.read_csv(dataset_path)\\n\\n # insert dataset label to the dataframes\\n dataset.insert(0, 'trial', dataset_label)\\n dataset.insert(0, 'maneuver', dataset_label.split('_')[0])\\n\\n # Datasets are stored in a dictionary\\n datasets_dic.update({dataset_label: dataset})\\n\\n # list of imported maneuvers\\n dataset_names = list(datasets_dic.keys())\\n\\n return datasets_dic, dataset_names\",\n \"def get_list_of_data_and_labels():\\n list_of_imgs = []\\n list_of_img_labels = []\\n for root, dirs, files in os.walk(config[\\\"PathToData\\\"], topdown=False):\\n for f in files:\\n ext = os.path.splitext(f)[-1].lower()\\n\\n if ext in config[\\\"ValidImageFileExtensions\\\"]:\\n list_of_imgs.append(os.path.join(root, f))\\n if ext in config[\\\"ValidLabelFileExtensions\\\"]:\\n list_of_img_labels.append(os.path.join(root, f))\\n\\n list_of_imgs_with_labels = []\\n list_of_corresponing_labels = []\\n for img_full_file_name in list_of_imgs:\\n img_file_name = os.path.splitext(img_full_file_name)[0].lower()\\n corresponding_label = [label_full_file_name for label_full_file_name in list_of_img_labels if os.path.splitext(label_full_file_name)[0].lower() == img_file_name]\\n if len(corresponding_label) != 0:\\n list_of_imgs_with_labels.append(img_full_file_name)\\n list_of_corresponing_labels.append(corresponding_label[0])\\n\\n assert len(list_of_imgs_with_labels) == len(list_of_corresponing_labels)\\n\\n return list_of_imgs_with_labels, list_of_corresponing_labels\",\n \"def get_corpus_filenames():\\n corpus_file_list = []\\n corpus_files = csv.reader(open('./gothic_text_data.csv'), delimiter=\\\",\\\", quotechar='\\\"')\\n\\n for row in corpus_files:\\n if row[0] != \\\"Title\\\":\\n corpus_file_list.append(row[14])\\n return corpus_file_list\",\n \"def load_data(filename):\\n assert os.path.exists(filename)==True\\n dat = scipy.io.loadmat(filename)\\n inputs = dat['inputs']\\n #print len(inputs)\\n targets = dat['targets']\\n #print len(targets)\\n assert len(inputs)==len(targets)\\n\\n global alldata\\n global indim \\n global outdim\\n\\n indim = len(inputs[0])\\n outdim = 1\\n #print indim\\n alldata = ClassificationDataSet(indim, outdim, nb_classes = 8)\\n alldata.setField('input',inputs)\\n alldata.setField('target',targets)\\n\\n assert len(alldata['input'])==len(alldata['target'])\\n print type(alldata)\",\n \"def get_test_files(self):\\n train_dir = os.path.join(self.data_dir, \\\"test_{}_new\\\".format(self.patient_no))\\n filenames = os.listdir(train_dir)\\n interm = ((os.path.splitext(f)[0].split(\\\"_\\\"), os.path.join(train_dir, f)) for f in filenames)\\n return [(int(p[0][1]), int(p[0][2]), p[1]) for p in interm]\",\n \"def read_metadata_mat_file(meta_mat):\\n mat = loadmat(meta_mat, squeeze_me=True)\\n synsets = mat['synsets']\\n cost_matrix = mat['cost_matrix']\\n new_dtype = numpy.dtype([\\n ('ILSVRC2010_ID', numpy.int16),\\n ('WNID', ('S', max(map(len, synsets['WNID'])))),\\n ('wordnet_height', numpy.int8),\\n ('gloss', ('S', max(map(len, synsets['gloss'])))),\\n ('num_children', numpy.int8),\\n ('words', ('S', max(map(len, synsets['words'])))),\\n ('children', (numpy.int8, max(synsets['num_children']))),\\n ('num_train_images', numpy.uint16)\\n ])\\n new_synsets = numpy.empty(synsets.shape, dtype=new_dtype)\\n for attr in ['ILSVRC2010_ID', 'WNID', 'wordnet_height', 'gloss',\\n 'num_children', 'words', 'num_train_images']:\\n new_synsets[attr] = synsets[attr]\\n children = [numpy.atleast_1d(ch) for ch in synsets['children']]\\n padded_children = [\\n numpy.concatenate((c,\\n -numpy.ones(new_dtype['children'].shape[0] - len(c),\\n dtype=numpy.int16)))\\n for c in children\\n ]\\n new_synsets['children'] = padded_children\\n return new_synsets, cost_matrix\",\n \"def filenames(self):\\n pass\",\n \"def _compile_data(tmp_dir, datasets, filename):\\n filename = os.path.join(tmp_dir, filename)\\n with tf.gfile.GFile(filename + \\\".lang1\\\", mode=\\\"w\\\") as lang1_resfile:\\n with tf.gfile.GFile(filename + \\\".lang2\\\", mode=\\\"w\\\") as lang2_resfile:\\n for dataset in datasets:\\n url = dataset[0]\\n compressed_filename = os.path.basename(url)\\n compressed_filepath = os.path.join(tmp_dir, compressed_filename)\\n\\n lang1_filename = dataset[0]\\n lang2_filename = dataset[1]\\n lang1_filepath = os.path.join(tmp_dir, lang1_filename)\\n lang2_filepath = os.path.join(tmp_dir, lang2_filename)\\n is_sgm = (lang1_filename.endswith(\\\"sgm\\\") and\\n lang2_filename.endswith(\\\"sgm\\\"))\\n\\n return filename\",\n \"def get_files(self):\\n self.cursor.execute(self.__get_contest_query__())\\n result = self.cursor.fetchall()\\n with open(self.country+'.txt', 'w') as outfile:\\n for image in result:\\n img = WlmFile(image, self.country, outfile)\\n img.save()\",\n \"def datasets(self):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62999743","0.5992772","0.5919344","0.58812904","0.5764292","0.57600445","0.5720086","0.56433666","0.5607395","0.5561246","0.55274653","0.55114895","0.5472151","0.54595053","0.54580384","0.5449727","0.54414546","0.54392225","0.54072315","0.5384773","0.53776836","0.5372219","0.536323","0.5352726","0.5342113","0.53379977","0.53359866","0.5332669","0.5313846","0.5292724","0.52835923","0.52835923","0.52615666","0.5259857","0.5234942","0.52349013","0.52310145","0.5219536","0.52081215","0.52059954","0.520032","0.5200134","0.51979744","0.5183418","0.51783514","0.51769125","0.5165711","0.516131","0.51606315","0.5154892","0.51511765","0.5146269","0.5144914","0.51438904","0.51419914","0.51418","0.51326394","0.5121491","0.51112115","0.5105522","0.51035327","0.51023763","0.5097696","0.5097208","0.50861675","0.5082665","0.5078429","0.50760174","0.5075736","0.5072477","0.5067947","0.506501","0.5048466","0.5046804","0.50315607","0.50128204","0.5008887","0.5005297","0.49916565","0.49907425","0.49889064","0.49853098","0.49850887","0.4984218","0.49826175","0.49792832","0.49791867","0.49664757","0.49629924","0.495952","0.49576715","0.49563175","0.4955954","0.49558163","0.4952069","0.4944171","0.4943602","0.49433285","0.49418038","0.4937955"],"string":"[\n \"0.62999743\",\n \"0.5992772\",\n \"0.5919344\",\n \"0.58812904\",\n \"0.5764292\",\n \"0.57600445\",\n \"0.5720086\",\n \"0.56433666\",\n \"0.5607395\",\n \"0.5561246\",\n \"0.55274653\",\n \"0.55114895\",\n \"0.5472151\",\n \"0.54595053\",\n \"0.54580384\",\n \"0.5449727\",\n \"0.54414546\",\n \"0.54392225\",\n \"0.54072315\",\n \"0.5384773\",\n \"0.53776836\",\n \"0.5372219\",\n \"0.536323\",\n \"0.5352726\",\n \"0.5342113\",\n \"0.53379977\",\n \"0.53359866\",\n \"0.5332669\",\n \"0.5313846\",\n \"0.5292724\",\n \"0.52835923\",\n \"0.52835923\",\n \"0.52615666\",\n \"0.5259857\",\n \"0.5234942\",\n \"0.52349013\",\n \"0.52310145\",\n \"0.5219536\",\n \"0.52081215\",\n \"0.52059954\",\n \"0.520032\",\n \"0.5200134\",\n \"0.51979744\",\n \"0.5183418\",\n \"0.51783514\",\n \"0.51769125\",\n \"0.5165711\",\n \"0.516131\",\n \"0.51606315\",\n \"0.5154892\",\n \"0.51511765\",\n \"0.5146269\",\n \"0.5144914\",\n \"0.51438904\",\n \"0.51419914\",\n \"0.51418\",\n \"0.51326394\",\n \"0.5121491\",\n \"0.51112115\",\n \"0.5105522\",\n \"0.51035327\",\n \"0.51023763\",\n \"0.5097696\",\n \"0.5097208\",\n \"0.50861675\",\n \"0.5082665\",\n \"0.5078429\",\n \"0.50760174\",\n \"0.5075736\",\n \"0.5072477\",\n \"0.5067947\",\n \"0.506501\",\n \"0.5048466\",\n \"0.5046804\",\n \"0.50315607\",\n \"0.50128204\",\n \"0.5008887\",\n \"0.5005297\",\n \"0.49916565\",\n \"0.49907425\",\n \"0.49889064\",\n \"0.49853098\",\n \"0.49850887\",\n \"0.4984218\",\n \"0.49826175\",\n \"0.49792832\",\n \"0.49791867\",\n \"0.49664757\",\n \"0.49629924\",\n \"0.495952\",\n \"0.49576715\",\n \"0.49563175\",\n \"0.4955954\",\n \"0.49558163\",\n \"0.4952069\",\n \"0.4944171\",\n \"0.4943602\",\n \"0.49433285\",\n \"0.49418038\",\n \"0.4937955\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.73199314"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23198,"cells":{"query":{"kind":"string","value":"Loads and extracts signals from a troika data file."},"document":{"kind":"string","value":"def LoadTroikaDataFile(data_fl):\n data = sp.io.loadmat(data_fl)['sig']\n return data[2:]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_signal_raw(filepath):\n signal_raw = sio.loadmat(filepath)['signal_raw']\n return signal_raw","def _load_unlabeled(self, path):\n signal, info = wfdb.rdsamp(path)\n self.fs = 250\n self.lead_match = ['anonymous1', 'anonymous2']\n self.raw_data = np.transpose(np.array([signal]), (2, 0, 1))\n self.symbol = []\n self.coords = []\n self.label_name = None\n self._generate_beatlabel_from_estimation()","def load_signal_file(self, path):\n self.status.info()\n try:\n file_name = os.path.basename(path)\n module_name, ext = os.path.splitext(file_name)\n with open(path) as sig_file:\n module = imp.load_source(module_name, path, sig_file)\n except Exception:\n self.status.error(\"Error reading '%s' signal file\" % file_name)\n return\n\n for attr, obj in module.__dict__.items():\n if isinstance(obj, type) and issubclass(obj, ogre.Signal):\n sig = obj()\n self.sig_list.append((attr, sig))\n self.sig_frame.add(\"%s.%s\" % (module_name, attr))\n\n self.log_frame.log_import(module_name)","def load_synthetic_data():\n\n pickle_object = FM().data_file \n\n with pickle_object.open('rb') as data_file: \n return pickle.load(data_file)","def load_signal(DS, sampling ):\n my_db = ppg_db()\n\n file_records = list()\n\n # get all file in the Normal directory\n folder_name = 'Normal/'\n list_file = os.listdir(pathDB + folder_name)\n list_file.sort()\n\n for file in list_file:\n # check just file name\n if file[0:4] in DS:\n file_records.append(file)\n\n # get all file in the AF directory\n folder_name = 'AF/'\n list_file = os.listdir(pathDB + folder_name)\n list_file.sort()\n\n for file in list_file:\n #print(file[0:5])\n if file[0:5] in DS:\n file_records.append(file)\n\n # inialize variable\n class_ID = [[] for i in range(len(DS))]\n beat = [[] for i in range(len(DS))]\n valid_R = [ np.array([]) for i in range(len(DS))]\n\n for myFile in range(0, len(file_records)):\n print(\"Processing signal... \" + str(myFile) + \" / \" + str(len(file_records)) + \"...\")\n\n\n # check is each file is named with Normal or AF\n # print(file_records[myFile][0]) => N or A\n if (file_records[myFile][0] == 'N'):\n filename = pathDB + 'Normal/' + file_records[myFile]\n print(\"file name \" + str(filename))\n f = open(filename, 'rb')\n reader = csv.reader(f, delimiter=',')\n\n RAW_signal_N = []\n for row in reader:\n # save signal to list\n RAW_signal_N.append(float(row[0]))\n\n # iterate in signal\n selectedSignal = []\n for i in range(0,len(RAW_signal_N)):\n selectedSignal.append(RAW_signal_N[i])\n # sampling every 180 unit\n if( i % (sampling-1) == 0 and i > 0 ):\n beat[myFile].append(selectedSignal)\n class_ID[myFile].append(0) # label the beat for Normal\n selectedSignal = []\n\n\n elif(file_records[myFile][0] == 'A'):\n filename = pathDB + 'AF/' + file_records[myFile]\n print(filename)\n f = open(filename, 'rb')\n reader = csv.reader(f, delimiter=',')\n\n RAW_signal_AF = []\n for row in reader:\n # save signal to list\n RAW_signal_AF.append(float(row[0]))\n\n # iterate in signal\n selectedSignal = []\n for i in range(0, len(RAW_signal_AF)):\n selectedSignal.append(RAW_signal_AF[i])\n # sampling every 180 unit\n if (i % (sampling - 1) == 0 and i > 0):\n beat[myFile].append(selectedSignal)\n class_ID[myFile].append(1) # label the beat for AF\n selectedSignal = []\n\n print(\"Complete Load File\")\n my_db.filename = file_records\n my_db.beat = beat\n my_db.class_ID = class_ID\n\n return my_db","def updateSignals(self):\n self.parser.read(self.file)\n self.signalType = self.parser.get('Signals', 'signalType')\n if self.signalType == 'single':\n self.single = self.parser.get('Signals', 'single')\n elif self.signalType == 'dual':\n self.fast = self.parser.getint('Signals', 'fast')\n self.slow = self.parser.getint('Signals', 'slow')\n elif self.signalType == 'ribbon':\n self.ribbonStart = self.parser.get('Signals', 'ribbonStart')\n self.numRibbon = self.parser.get('Signals', 'numRibbon')\n self.ribbonSpacing = self.parser.get('Signals', 'ribbonSpacing')","def loadPulseData(filename, suffix = ''):\n data = np.genfromtxt(filename+'.txt', skip_header=3, names=True,\n dtype='i8,f8,S5,f8,f8,f8,f8,f8,f8')\n print \"Importing...\\n\"\n for key in data.dtype.fields.keys():\n name = key + suffix\n print name\n globals()[name] = data[key]","def loadFNIRS(self,filepath):\r\n self.tree = ET.parse(filepath)\r\n self.data = self.tree.getroot().find(\"data\")\r\n self.samplerate = float(self.tree.getroot().find('device').find('samplerate').text)\r\n self.sensors = [i.text for i in self.tree.getroot().find('columns')]\r\n self.sensorMask = [True]*len(self.sensors)\r\n self.measurements = len(self.tree.getroot().find('data'))","def load_from_file(self, trfilename):\n # Read the report file and populate the datastructure\n for ll in open(trfilename):\n timestr = ll.split()[0]\n label = \" \".join(ll.split()[1:])\n time = float(timestr)\n\n if label in (\"init-trigger\", \"trigger\"):\n self.trtimes.append(time)\n\n elif label == \"sound-start\":\n self.soundstarttime = time\n\n elif label == \"sound-stop\":\n self.soundstoptime = time\n\n else:\n self.otherlabels.append((time, label))\n\n # Fix weird TR times\n itrtimes = np.diff(self.trtimes)\n badtrtimes = np.nonzero(itrtimes > (itrtimes.mean()*1.5))[0]\n newtrs = []\n for btr in badtrtimes:\n # Insert new TR where it was missing..\n newtrtime = self.trtimes[btr]+self.expectedtr\n newtrs.append((newtrtime, btr))\n\n for ntr, btr in newtrs:\n self.trtimes.insert(btr+1, ntr)","def load_data(path: str, keep_signals: AbstractSet[str] = None) -> List[SimData]:\r\n sim_datas = list()\r\n\r\n for file_name in sorted(os.listdir(path)):\r\n if not file_name.endswith(\".npy\"):\r\n continue\r\n file_name = file_name[:-4]\r\n\r\n try:\r\n signal, amplitude = file_name.split(\"_\")\r\n amplitude = float(amplitude)\r\n except ValueError:\r\n continue\r\n\r\n data = np.load(os.path.join(path, f\"{file_name}.npy\"))\r\n\r\n if keep_signals is None:\r\n vs = {n: data[n] for n in data.dtype.names if n != \"time\"}\r\n else:\r\n vs = {\r\n n: data[n]\r\n for n in data.dtype.names\r\n if n != \"time\" and n in keep_signals\r\n }\r\n\r\n sim_datas.append(\r\n SimData(\r\n signal=signal, amplitude=amplitude, time=data[\"time\"], vs=vs, fs=None\r\n )\r\n )\r\n\r\n return sim_datas","def _load(self):\n # Extract the ASCII header (5 first lines)\n with open(self._xst_bin, 'rb') as f:\n header = list(islice(f, 0, 5))\n assert header[0] == b'HeaderStart\\n',\\\n 'Wrong header start'\n assert header[-1] == b'HeaderStop\\n',\\\n 'Wrong header stop'\n header = [s.decode('utf-8') for s in header]\n hd_size = sum([len(s) for s in header])\n\n # Parse informations into a metadata dictionnary\n keys = ['freq', 'ma', 'accu']\n search = ['Freq.List', 'Mr.List', 'accumulation']\n types = ['float64', 'int', 'int']\n for key, word, typ in zip(keys, search, types):\n for h in header:\n if word in h:\n self.meta[key] = np.array(\n h.split('=')[1].split(','),\n dtype=typ\n )\n\n # Deduce the dtype for decoding\n n_ma = self.meta['ma'].size\n n_sb = self.meta['freq'].size\n dtype = np.dtype(\n [('jd', 'float64'),\n ('data', 'complex64', (n_sb, n_ma*n_ma*2 + n_ma))]\n )\n\n # Decoding the binary file\n tmp = np.memmap(\n filename=self._xst_bin,\n dtype='int8',\n mode='r',\n offset=hd_size\n )\n decoded = tmp.view(dtype)\n\n self.data = decoded['data'] / self.meta['accu']\n self.time = Time(decoded['jd'], format='jd', precision=0)\n\n return","def load_data(self):\n logging.debug('Loading data from file ({})...'.format(self.file_name))\n parsed_data = list()\n with open(self.file_name) as file_data:\n for line in file_data.readlines():\n temp = dict()\n if 'JD' in line:\n continue\n line = line.split()\n temp['ts'], temp['mag'], temp['dif'] = float(line[0][:14]), float(line[1]), float(line[2])\n temp['f_mag'] = self.kalman_filter(temp['mag'])\n temp['dt'] = self.jd_to_datetime(temp['ts'])\n temp['dt_cor'] = self.jd_to_datetime(temp['ts'] - TIME_CRT)\n parsed_data.append(temp)\n logging.debug(' {} records loaded.'.format(len(parsed_data)))\n logging.debug(parsed_data[0])\n self.data_stream = parsed_data","def _read_signals(edf_file, header):\n signals = OrderedDict([(label, []) for label in header['label']])\n\n while True:\n try:\n record = _read_record(edf_file, header)\n except EOFError:\n break\n\n for label, signal in record.items():\n signals[label].append(signal)\n\n for label, signal in signals.items():\n signals[label] = np.concatenate(signal)\n\n return signals","def load_list(self):\n with open('/home/roman/Skola/ProjektyMimo/ApkaNaSkolu/output.dat', 'rb') as f:\n self.events = pickle.load(f)","def load_data(self) -> None:","def load(filename):\n root,ext = _os_path.splitext(filename)\n loader = LOADER[ext]\n frequency,raw_signal = loader(filename)\n iinfo = _numpy.iinfo(raw_signal.dtype)\n raw_signal_midpoint = (iinfo.max + iinfo.min)/2.\n raw_signal_range = iinfo.max - raw_signal_midpoint\n unit_output_signal = (raw_signal - raw_signal_midpoint)/raw_signal_range\n return (frequency, unit_output_signal)","def _load_qt(self, path):\n signal, info = wfdb.rdsamp(path)\n ann_1 = wfdb.rdann(path, extension='q1c')\n ann_2 = wfdb.rdann(path, extension='qt1')\n self.fs = 250\n self.lead_match = ['anonymous1', 'anonymous2']\n self.raw_data = np.transpose(np.array([signal]), (2, 0, 1))\n self.symbol = [ann_1.symbol, ann_2.symbol]\n self.coords = [ann_1.sample, ann_2.sample]\n if list(np.unique(np.array(self.symbol[0]))) != ['(', ')', 'N', 'p', 't'] and list(np.unique(np.array(self.symbol[0]))) != ['(', ')', 'N', 'p', 't', 'u']:\n print(\"Invalid symbols in ECG annotations.\")\n raise ValueError\n self.label_name = ['(', 'p', ')', '(', 'N', ')', 't', ')']\n self._generate_beatlabel_from_label()","def load_timestamps(data_path):\n timestamp_file = os.path.join(data_path, 'oxts', 'timestamps.txt')\n\n # Read and parse the timestamps\n timestamps = []\n with open(timestamp_file, 'r') as f:\n for line in f.readlines():\n # NB: datetime only supports microseconds, but KITTI timestamps\n # give nanoseconds, so need to truncate last 4 characters to\n # get rid of \\n (counts as 1) and extra 3 digits\n t = datetime.datetime.strptime(line[:-4], '%Y-%m-%d %H:%M:%S.%f')\n timestamps.append(t)\n return timestamps","def load_data(self):\n\t\ti = 0\n\n\t\tpaths = glob.glob(self.file_path+'/rollout_*')\n\t\tself.rollouts = []\n\n\n\t\tfor path in paths:\n\t\t\tdata_point = np.load(path,encoding='latin1')\n\t\t\tself.rollouts.append(data_point)\n\n\t\treturn paths","def load_data():\r\n print ('Loadng all the file one time......')\r\n if not os.path.exists('cifar.pkl'):\r\n set_data()\r\n with open('cifar.pkl', 'rb') as cifar_pickle:\r\n data = six.moves.cPickle.load(cifar_pickle)\r\n return data","def __parseStatechartSignalsH(self, file):\n # Read file\n f = open(file,\"r\")\n lines = f.readlines()\n #\n event_lines = []\n event_capture = False\n event_dict = dict()\n # Capture lines with user events\n for line in lines:\n if line.find(\"User defined signals\") > -1:\n event_capture = True\n if event_capture == True:\n event_lines.append(line)\n if line.find(\"Timer Events\") > -1\\\n or line.find(\"Maximum signal id\") > -1\\\n or line.find(\"State-Machine internal signals\") > -1:\n break\n # Make list of string event names and enum event values\n event_lines = map(lambda x: x.strip(), event_lines[1:-1])[:-1]\n event_names = map(lambda x: x.split(\",\")[0].strip(), event_lines)\n x = map(lambda x: x.split(\",\")[1].split(\"/*\")[1].split(\"*/\")[0].strip(), event_lines)\n event_nums = map(lambda x: int(x,16), x)\n # Create the dictionary\n for ev in enumerate(event_names):\n event_dict[event_nums[ev[0]]] = ev[1]\n #print ev\n return event_dict","def load_patient_data(db_dir, patient_id, include_labels=True, unzipped=False):\n signal = load_signal(db_dir, patient_id, unzipped=unzipped)\n if include_labels:\n labels = load_labels(db_dir, patient_id, unzipped=unzipped)\n return signal, labels\n else:\n return signal, None","def readSigfile(filename):\r\n gtTrace = []\r\n gtTime = []\r\n gtHR = []\r\n with open(filename,'r') as f :\r\n x = f.readlines()\r\n s = x[0].split(' ')\r\n s = list(filter(lambda a:a != '',s))\r\n gtTrace = np.array(s).astype(np.float64)\r\n\r\n t = x[2].split(' ')\r\n t = list(filter(lambda a: a != '' ,t))\r\n gtTime = np.array(t).astype(np.float64)\r\n\r\n hr = x[1].split(' ')\r\n hr = list(filter(lambda a: a != '' ,hr))\r\n gtHR = np.array(hr).astype(np.float64)\r\n\r\n data = np.array(gtTrace)\r\n time = np.array(gtTime)\r\n hr = np.array(gtHR)\r\n\r\n return data,hr","def load_data(self):\n with open(self.file_name) as f:\n lines = f.readlines()\n\n labels = list()\n all_dat = list()\n for i, l in enumerate(lines):\n\n labels.append(int(l[0]))\n\n l = gensim.utils.any2unicode(l)\n all_dat.append(LabeledSentence(l.split(\"\\t\")[-1], [i]))\n\n return all_dat, np.asarray(labels)","def loadSamples(filename):\n data = []\n with open(filename, encoding=\"utf-8\") as f_obj:\n reader = csv.DictReader(f_obj, delimiter=';')\n for line in reader:\n Tetta = float(line['dTetta'])\n Lambda = float(line['Lambda'])\n item = TSample(Tetta, Lambda)\n data.append(item)\n return data","def load_signal_data():\n # Load images, annotations path\n images = sorted(glob(IMAGES_PATH + '/*'))\n annotations = sorted(glob(ANNOTATIONS_PATH + '/*'))\n\n patten = 'left'\n left_images, right_image = [], []\n left_annotations, right_annotations = [], []\n for image, annotation in zip(images, annotations):\n if len(re.findall(patten, image)):\n left_images.append(image)\n left_annotations.append(annotation)\n else:\n right_image.append(image)\n right_annotations.append(annotation)\n return left_images, right_image, left_annotations, right_annotations","def data_clean_CWRU(self):\r\n\r\n os.chdir(self.path_txt)\r\n files, filelabesl_wc, filelabels_fs = self.filename_CWRU()\r\n\r\n signals = []\r\n for file in files:\r\n try:\r\n with open(file, \"r\") as fr:\r\n signal = fr.readlines()\r\n signal = np.array([float(item.strip()) for item in signal])\r\n except IOError:\r\n raise IOError(\"some wrong with the file %s\" % file)\r\n signals.append(signal.reshape(1, -1))\r\n\r\n os.chdir(self.path)\r\n return signals, filelabesl_wc, filelabels_fs","def data_from_file(ta_file):\n file_handle = open(ta_file, \"r\")\n #\n # We try to maintain read-compatibility with all versions of Turtle Art.\n # Try pickle first; then different versions of json.\n #\n try:\n _data = pickle.load(file_handle)\n except:\n # Rewind necessary because of failed pickle.load attempt\n file_handle.seek(0)\n _text = file_handle.read()\n _data = data_from_string(_text)\n file_handle.close()\n return _data","def load_data(self):","def _load_ludb(self, path):\n signal, info = wfdb.rdsamp(path)\n self.fs = 500\n self.lead_match = ['I', 'II', 'III', 'aVR', 'aVL', 'aVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']\n self.raw_data = np.transpose(np.array([signal]), (2, 0, 1))\n self.symbol = []\n self.coords = []\n for lead in ['i', 'ii', 'iii', 'avr', 'avl', 'avf', 'v1', 'v2', 'v3', 'v4', 'v5', 'v6']:\n ann_ii = wfdb.rdann(path, extension='atr_{}'.format(lead))\n symbol_1 = ann_ii.symbol\n coords_1 = ann_ii.sample\n if list(np.unique(np.array(symbol_1))) != ['(', ')', 'N', 'p', 't'] and list(np.unique(np.array(symbol_1))) != ['(', ')', 'N', 'p', 't', 'u']:\n print(\"Invalid symbols in ECG annotations.\")\n raise ValueError\n self.symbol.append(symbol_1)\n self.coords.append(coords_1)\n self.label_name = ['(', 'p', ')', '(', 'N', ')', '(', 't', ')']\n self._generate_beatlabel_from_label()","def load_data(self) -> None:\n self.paths: List[str] = []\n self.durations: List[float] = []\n self.transcriptions: List[str] = []\n\n def raise_(err):\n \"\"\"raises error if problem during os.walk\"\"\"\n raise err\n\n for subset in self.subsets:\n subset_path = os.path.join(self.root, self.base_dir, subset)\n for root, dirs, files in os.walk(subset_path, onerror=raise_):\n if not files:\n continue\n matches = fnmatch.filter(files, \"*.trans.txt\")\n assert len(matches) == 1, \"> 1 transcription file found\"\n self._parse_transcription_file(root, matches[0])\n\n self._sort_by_duration()","def read_raw_data(self):\n dat_file = os.path.join(DATA_DIR, self.patient_number + '.txt')\n if not os.path.exists(dat_file):\n raise AssertionError(\"{} doesn't exist.\".format(dat_file))\n time = []\n voltage1 = []\n voltage2 = []\n with open(dat_file, 'r') as fd:\n for line in fd:\n line = line.split()\n time.append(line[0])\n voltage1.append(float(line[1]))\n voltage2.append(float(line[2]))\n\n tags_file = os.path.join(DATA_DIR, self.patient_number + '_tag.txt')\n if not os.path.exists(dat_file):\n raise AssertionError(\"{} doesn't exist.\".format(tags_file))\n tags_time = []\n tags = []\n r_peaks_indexes = []\n with open(tags_file, 'r') as fd:\n for line in fd:\n line = line.split()\n tags_time.append(line[0])\n tags.append(line[2])\n r_peaks_indexes.append(int(line[1]))\n return time, voltage1, voltage2, tags_time, tags, r_peaks_indexes","def load(filename):\r\n wholeTract= nib.streamlines.load(filename) \r\n wholeTract = wholeTract.streamlines\r\n return wholeTract","def read(self, filename=None, **kwargs):\n \n # --- Standard tests and exceptions (generic code)\n if filename:\n self.filename = filename\n if not self.filename:\n raise Exception('No filename provided')\n if not os.path.isfile(self.filename):\n raise OSError(2,'File not found:',self.filename)\n if os.stat(self.filename).st_size == 0:\n raise EmptyFileError('File is empty:',self.filename)\n try:\n from nptdms import TdmsFile\n except:\n raise Exception('Install the library nptdms to read this file')\n\n fh = TdmsFile(self.filename, read_metadata_only=False)\n # --- OLD, using some kind of old version of tdms and probably specific to one file\n # channels_address = list(fh.objects.keys())\n # channels_address = [ s.replace(\"'\",'') for s in channels_address]\n # channel_keys= [ s.split('/')[1:] for s in channels_address if len(s.split('/'))==3]\n # # --- Setting up list of signals and times\n # signals=[]\n # times=[]\n # for i,ck in enumerate(channel_keys):\n # channel = fh.object(ck[0],ck[1])\n # signals.append(channel.data)\n # times.append (channel.time_track())\n\n # lenTimes = [len(time) for time in times]\n # minTimes = [np.min(time) for time in times]\n # maxTimes = [np.max(time) for time in times]\n # if len(np.unique(lenTimes))>1:\n # print(lenTimes)\n # raise NotImplementedError('Different time length') \n # # NOTE: could use fh.as_dataframe\n # if len(np.unique(minTimes))>1:\n # print(minTimes)\n # raise NotImplementedError('Different time span') \n # if len(np.unique(maxTimes))>1:\n # print(maxTimes)\n # raise NotImplementedError('Different time span') \n # # --- Gathering into a data frame with time\n # time =times[0]\n # signals = [time]+signals\n # M = np.column_stack(signals)\n # colnames = ['Time_[s]'] + [ck[1] for ck in channel_keys]\n # self['data'] = pd.DataFrame(data = M, columns=colnames)\n # --- NEW\n self['data'] = fh\n\n #for group in fh.groups():\n # for channel in group.channels():\n # #channel = group['channel name']\n # print('Group:',group.name , 'Chan:',channel.name)\n # channel_data = channel[:]\n # if len(channel_data)>0:\n # print(' ', type(channel_data))\n # #print(' ', len(channel_data))\n # print(' ', channel_data)\n # print(' ', channel_data[0])\n # try:\n # print(channel.time_track())\n # except KeyError:\n # print('>>> No time track')","def load(self):\n path = self.directory + \"/\" + self.filename\n dictionary = pickle.load(open(path, 'rb'))\n self.coefficients = dictionary[\"coefficients\"]\n self.display = dictionary[\"display\"]\n self.construction = dictionary[\"construction\"]\n self.drawing = dictionary[\"drawing\"]\n self.updateSample()\n self.context.console.append(\"The Fourier components are loaded.\")","def read_probes(files, noisy=False, locations=False, datetimes=False):\n\n if len(files) == 0:\n raise Exception('No files provided.')\n\n if not isinstance(files, (list, tuple)):\n files = [files]\n\n for i, file in enumerate(files):\n if noisy:\n print('Loading file {} of {}...'.format(i + 1, len(files)), end=' ')\n\n # Get the header so we can extract the position data.\n with open(file, 'r') as f:\n # Latitude and longitude is stored at line 15 (14 in sPpython\n # counting). Eastings and northings are at 13 (12 in Python\n # indexing).\n lonlatz = [float(pos.strip()) for pos in filter(None, f.readlines()[14].split(' '))]\n\n data = np.genfromtxt(file, skip_header=18)\n\n if i == 0:\n try:\n times = data[:, 0]\n values = data[:, 1:]\n except IndexError:\n times = data[0]\n values = data[1:]\n positions = lonlatz\n else:\n try:\n times = np.hstack((times, data[:, 0]))\n values = np.vstack((values, data[:, 1:]))\n except IndexError:\n times = np.hstack((times, data[0]))\n values = np.vstack((values, data[1:]))\n\n positions = np.vstack((positions, lonlatz))\n\n if noisy:\n print('done.')\n\n if datetimes:\n times = num2date(times, \"days since 1858-11-17 00:00:00\")\n\n # It may be the case that the files have been supplied in a random order,\n # so sort the values by time here.\n sidx = np.argsort(times)\n times = times[sidx]\n values = values[sidx, ...] # support both 1 and 2D data\n\n if locations:\n return times, values, positions\n else:\n return times, values","def convert(filename, signal=sampleArray(), \n centerEta = DEFCENTERETA, centerPhi = DEFCENTERPHI): \n numEvents = 0\n listOfSignals = []\n # First we open the file\n with open(filename, \"r\") as f:\n content = f.readlines()\n numEvents = len(content)\n for i in range(0, numEvents):\n if i % 1000 == 0:\n print(i)\n thisEvent = content[i]\n try:\n reducedEvent = convertEvent(\n thisEvent, centerEta, centerPhi, signal.shape[0], signal.shape[1]\n ) \n listOfSignals.append(reducedEvent)\n except indexError:\n 0\n print(\"Converted\", len(listOfSignals), \"out of\", numEvents, \"events\")\n return listOfSignals","def read_syn_data():\n dipy_home = pjoin(os.path.expanduser('~'), '.dipy')\n folder = pjoin(dipy_home, 'syn_test')\n t1_name = pjoin(folder, 't1.nii.gz')\n b0_name = pjoin(folder, 'b0.nii.gz')\n\n md5_dict = {'t1': '701bda02bb769655c7d4a9b1df2b73a6',\n 'b0': 'e4b741f0c77b6039e67abb2885c97a78'}\n\n check_md5(t1_name, md5_dict['t1'])\n check_md5(b0_name, md5_dict['b0'])\n\n t1 = nib.load(t1_name)\n b0 = nib.load(b0_name)\n return t1, b0","def _read_arasim_antenna_data(filename):\n data = {}\n freqs = set()\n thetas = set()\n phis = set()\n freq = 0\n with open(filename) as f:\n for line in f:\n words = line.split()\n if line.startswith('freq'):\n freq = 1\n if words[-1]==\"Hz\":\n pass\n elif words[-1]==\"kHz\":\n freq *= 1e3\n elif words[-1]==\"MHz\":\n freq *= 1e6\n elif words[-1]==\"GHz\":\n freq *= 1e9\n else:\n raise ValueError(\"Cannot parse line: '\"+line+\"'\")\n freq *= float(words[-2])\n freqs.add(freq)\n elif line.startswith('SWR'):\n swr = float(words[-1])\n elif len(words)==5 and words[0]!=\"Theta\":\n theta = int(words[0])\n thetas.add(theta)\n phi = int(words[1])\n phis.add(phi)\n db_gain = float(words[2])\n # AraSim actually only seems to use the sqrt of the gain\n # (must be gain in power, not voltage)\n # gain = np.sqrt(float(words[3]))\n gain = np.sqrt(10**(db_gain/10))\n phase = np.radians(float(words[4]))\n data[(freq, theta, phi)] = (gain, phase)\n\n # Convert data dictionary into 3-D array of responses\n response = np.empty((len(freqs), len(thetas), len(phis)),\n dtype=np.complex_)\n for i, freq in enumerate(sorted(freqs)):\n for j, theta in enumerate(sorted(thetas)):\n for k, phi in enumerate(sorted(phis)):\n gain, phase = data[(freq, theta, phi)]\n response[i, j, k] = gain * np.exp(1j*phase)\n\n response_data = (response, np.array(sorted(freqs)),\n np.array(sorted(thetas)), np.array(sorted(phis)))\n return _fix_response_wrapping(response_data)","def load_signal(db_dir, patient_id, unzipped=False, mmap_mode=None):\n if unzipped:\n signal = np.load(os.path.join(db_dir, '{:05d}_batched.npy'.format(patient_id)), mmap_mode=mmap_mode)\n else:\n signal = load_pkl(os.path.join(db_dir, '{:05d}_batched.pkl.gz'.format(patient_id)))\n return signal","def __parse(self):\n lines = self.file.readlines()\n for i in range(0, len(lines)):\n line = lines[i]\n tokens = line.split()\n if tokens[0] == \"#start\":\n trial_name = tokens[1]\n trial = Trial(trial_name)\n self.trials[trial_name] = trial\n elif tokens[0] == \"#end\":\n continue\n else:\n date_str = tokens[0] + \" \" + tokens[1]\n date = datetime.strptime(date_str, \"%m/%d/%y %H:%M:%S\")\n sound_file = line[18:-1].strip()\n event = Event(date, sound_file, 0)\n trial.addevent(event)","def load_ICA_data(subject, data_dir, file='post_ICA', preload=True):\n\tDS_dir = 'downsampled_128'\n\t#datadir='/Users/md42732/Desktop/data/EEG/MovieTrailers/Participants/%s/%s'%(subject, DS_dir)\n\tif file == 'post_ICA':\n\t\tds = io.read_raw_fif('%s/%s/%s/%s_postICA_rejected.fif'%(data_dir, subject, DS_dir, subject), preload=True)\n\telse:\n\t\tprint('No other file previously saved to load')\n\n\treturn ds","def _from_file(self, path):\r\n\r\n file = pathlib.Path(path)\r\n log.info(\"Extracting data from file: {}\".format(file))\r\n\r\n with open(file, 'r') as f:\r\n lines = f.readlines()\r\n\r\n self._extract_raw_data(lines)\r\n\r\n return","def t7_loadFile(self):\n print \"subspectrumFile\"\n filename = tkFileDialog.askopenfilename()\n filename = \"SubSpectrumData/\" + self.filenameparser(filename)\n self.t7_filename = filename","def t1_loadFile(self):\n print \"subspectrumFile\"\n filename = tkFileDialog.askopenfilename()\n filename = self.filenameparser(filename)\n self.t1_filename = filename","def spectre_tsv3(f):\n \n skip = 0\n while True:\n try: \n wav, flux, dflux = np.loadtxt(f, skiprows = skip, unpack = True)\n \n except ValueError:\n # Si les première lignes ont un en-tête\n skip += 1\n \n else:\n break\n \n return wav,flux","def t9_loadFile(self):\n print \"subspectrumFile\"\n filename = tkFileDialog.askopenfilename()\n filename = \"SubSpectrumData/\" + self.filenameparser(filename)\n orgin_file = self.filenameparser(filename)\n self.t9_filename = filename\n self.t9_orginfilename = orgin_file","def read_wavetxt(path):\n with open(path) as f:\n for line in f.readlines():\n line = line.strip()\n if 'SampleFrequence' in line:\n freq = int(line[16:])\n elif 'DataInput' in line:\n series = np.array(line[10:].split(',')).astype(np.float64)\n return (freq, series)","def _read_record(edf_file, header):\n labels = header['label']\n signals = OrderedDict()\n\n for channel in range(header['num_signals']):\n num_bytes = _bytes_per_record(channel, header)\n raw_bytes = edf_file.read(num_bytes)\n if not len(raw_bytes) == num_bytes:\n raise EOFError('Could not read a full record.')\n\n digital = np.fromstring(raw_bytes, _RAW_INT_FORMAT).astype(np.float)\n physical = _dig_to_phys(digital, channel, header)\n signals[labels[channel]] = physical\n\n return signals","def load(fnames, tag=None, inst_id=None):\n\n if not fnames:\n print('fnames are go')\n warnings.warn('You no got no fname, you no get no data')\n return pysat.DataFrame(None), pysat.Meta(None)\n elif len(fnames) == 1:\n print('fnames are greater than 1')\n meta = pysat.Meta()\n signal_meta = pysat.Meta()\n\n # load the rinex\n data = gr.load(fnames[0])\n # get the metadata from the xarray.Dataset\n xr_attrs = data.attrs\n # format the metadata\n# for at in xr_attrs:\n# print(type(at))\n# meta[at] = {'units': '', 'long_name': at}\n# keys = data.data_vars.keys()\n# for key in keys:\n# # find the xarray equivalents of units and long_name\n# print(key)\n# signal_meta[key] = {meta.labels.units: var_units[key][0],\n# meta.labels.name: var_units[key][1]}\n# # format the data\n# meta['signals'] = signal_meta\n# output = data.variables\n return data, meta\n else:\n raise ValueError('Only one filename currently supported')\n print('no idea wahts goin on')","def load_data():\n\n dump_path = dump_base + '/micro_poi/mpoi_info/'\n\n assert os.path.exists(dump_path)\n\n dpath = dump_path + 'shortest_path.pickle'\n paths = joblib.load(dpath)\n\n dpath = dump_path + 'path_list.pickle'\n path_list = joblib.load(dpath)\n\n dpath = dump_path + 'gain.pickle'\n gain = joblib.load(dpath)\n\n dpath = dump_path + 'stay.pickle'\n stay_time = joblib.load(dpath)\n\n dpath = dump_path + 'reach.pickle'\n reach_time = joblib.load(dpath)\n\n spath = dump_base + '/micro_poi/model_params.list'\n model_params = np.loadtxt(spath)\n\n return np.array(paths), path_list, gain, stay_time, reach_time, model_params","def test_load_gtis(self):\n fname = os.path.join(datadir, 'monol_testA.evt')\n load_gtis(fname, gtistring=\"GTI\")","def load_data(filename):\n hkas = HKArchiveScanner()\n hkas.process_file(filename)\n cat = hkas.finalize()\n fields, timelines = cat.get_data(['position'], short_match=True)\n return fields, timelines","def loadData(self,filepath):\r\n self.removeCheckbuttons()\r\n self.tree = ET.parse(filepath)# Parse xml Tree\r\n self.data = self.tree.getroot().find(\"data\")# Find Data\r\n self.sensors = [i.text for i in self.tree.getroot().find('columns')]# Get Sensor Names\r\n for s in self.sensors:# Add Each Sensor as Option\r\n self.addOption(s)","def spectre_tsv(f):\n \n skip = 0\n while True:\n try: \n wav, flux = np.loadtxt(f, skiprows = skip, unpack = True)\n \n except ValueError:\n # Si les première lignes ont un en-tête\n skip += 1\n \n else:\n break\n \n return wav,flux","def extract_from_file(self, data_file, data_path):\n with open(data_file, \"r\") as f:\n lines = f.readlines()\n\n # Add the complete path to each file name so that we can\n # properly load them into the CHOPPER\n data_paths = [os.path.join(data_path, line) for line in lines]\n\n spect_file_pairs = []\n for path in data_paths:\n # Use the file family to easily get the names of the different\n # file types!\n file_family = FileFamily(path)\n\n # Append tuple with (spect_file, label_mask_file)\n spect_file_pairs.append((file_family.fullpath(AudioType.SPECTRO), file_family.fullpath(AudioType.MASK)))\n\n return spect_file_pairs","def parse_file(self, file_path) -> list:\n data = []\n with open(file_path, 'rb') as f:\n lines = pickle.load(f)\n for line in lines:\n input, output = line\n if input.strip() == \"\" or output.strip() == \"\":\n continue\n input_len = len(input.split())\n output_len = len(output.split())\n if input_len > 50 or output_len > 50:\n continue\n data_item = Text2TextDataItem(input_text=input, output_text=output, tokenizer=self.tokenizer,\n share_vocab=self.share_vocab)\n data.append(data_item)\n return data","def entries_from_goes_ts_files(*files, default_waveunit=None, source=None):\n\n\n \"\"\"\n ts_goes = ts.TimeSeries(file)\n statinfo = os.stat(file)\n entry = DatabaseEntry(path=file)\n entry.size = statinfo.st_size\n\n #header['INSTRUME'] = header['TELESCOP']# So E.G. 'GOES 6' instead 'X-ray Detector'\n entry.instrument = ts_goes.meta.get('TELESCOP').values()\n entry.instrument = ts_goes.meta.get('TELESCOP').values()\n\n entry.wavemax = 0.8 # XRSB '1.0--8.0 $\\AA$'\n entry.wavemin = 0.05 # XRSA '0.5--4.0 $\\AA$'\n\n #\n entry.observation_time_start = ts_goes.meta.get('date-beg').values()[0]\n entry.observation_time_end = ts_goes.meta.get('date-end').values()[0]\n\n entry.metadata = ts_goes.meta.metadata[0][2]\n\n #entry.tags = [ sunpy.database.attrs.Tag('raw') ]\n \"\"\"\n\n\n for file in files:\n headers = fits.get_header(file)\n if isinstance(file, (str, six.text_type)):\n filename = file\n else:\n filename = getattr(file, 'name', None)\n statinfo = os.stat(file)\n #print('a header')\n entry = DatabaseEntry(path=filename)\n entry.size = statinfo.st_size\n\n # Add/tweak start/end entries for GOES\n if headers[0].get('TELESCOP','') != '':\n #header['INSTRUME'] = header['TELESCOP']# So E.G. 'GOES 6' instead 'X-ray Detector'\n entry.instrument = headers[0]['TELESCOP']\n elif headers[1].get('TELESCOP','') != '':\n entry.instrument = headers[1]['TELESCOP']\n if (headers[0].get('DATE-OBS','') != ''):\n if is_time_in_given_format(headers[0]['DATE-OBS'], '%d/%m/%Y'):\n start_time = datetime.strptime(headers[0]['DATE-OBS'], '%d/%m/%Y')\n elif is_time_in_given_format(headers[0]['DATE-OBS'], '%d/%m/%y'):\n start_time = datetime.strptime(headers[0]['DATE-OBS'], '%d/%m/%y')\n else:\n start_time = parse_time(headers[0]['DATE-OBS'])\n elif (headers[1].get('DATE-OBS','') != ''):\n if is_time_in_given_format(headers[1]['DATE-OBS'], '%d/%m/%Y'):\n start_time = datetime.strptime(headers[1]['DATE-OBS'], '%d/%m/%Y')\n elif is_time_in_given_format(headers[1]['DATE-OBS'], '%d/%m/%y'):\n start_time = datetime.strptime(headers[1]['DATE-OBS'], '%d/%m/%y')\n else:\n start_time = parse_time(headers[1]['DATE-OBS'])\n\n if (headers[0].get('DATE-END','') != ''):\n if is_time_in_given_format(headers[0]['DATE-END'], '%d/%m/%Y'):\n end_time = datetime.strptime(headers[0]['DATE-END'], '%d/%m/%Y')\n elif is_time_in_given_format(headers[0]['DATE-END'], '%d/%m/%y'):\n end_time = datetime.strptime(headers[0]['DATE-END'], '%d/%m/%y')\n else:\n end_time = parse_time(headers[0]['DATE-END'])\n elif (headers[1].get('DATE-END','') != ''):\n if is_time_in_given_format(headers[1]['DATE-END'], '%d/%m/%Y'):\n end_time = datetime.strptime(headers[1]['DATE-END'], '%d/%m/%Y')\n elif is_time_in_given_format(headers[1]['DATE-END'], '%d/%m/%y'):\n end_time = datetime.strptime(headers[1]['DATE-END'], '%d/%m/%y')\n else:\n end_time = parse_time(headers[1]['DATE-END'])\n else:\n end_time = start_time + timedelta(days=1,seconds=-1)\n\n # Add these to the entry\n entry.observation_time_start = start_time\n entry.observation_time_end = end_time\n\n entry.wavemax = 0.8 # XRSB '1.0--8.0 $\\AA$'\n entry.wavemin = 0.05 # XRSA '0.5--4.0 $\\AA$'\n\n if source:\n entry.source = source\n\n entry.metadata = MetaDict(headers[1])\n #entry.tags = sunpy.database.attrs.Tag('raw')\n\n #entry = DatabaseEntry(instrument='EIT', wavemin=25.0)\n\n #return entry\n yield entry","def readData(pulse_dir, label_filename, data_description):\n print('=' * 20, \"reading in data...\", '=' * 20)\n global Subject\n\n # Modify the root directory of pulse data in Subject\n Subject.pulse_dir = pulse_dir\n\n # Read the label file\n label_file = pd.read_excel(label_filename)\n subject_names = label_file['subject'].dropna().values\n\n subject_list = []\n for i in range(len(subject_names)):\n try:\n subject_list.append(\n Subject(subject_names[i], label_df=label_file.iloc[i * 20:(i + 1) * 20:, 1:], data_description=data_description))\n except Exception as e:\n print(\"Exeception in data.py\")\n print(e)\n\n print('=' * 20, \"All valid data are read\", '=' * 20)\n return subject_list, subject_names","def load(self, progressHandler=None):\n soundingFile = self.soundingFile\n\n # create a null handler if input progressHandler is None:\n if not progressHandler:\n def progressHandler(*args):\n return None\n\n if self.UTC_offset == 0:\n self.UTC_offset = tools.getUTCOffset(self.launchSiteLat,\n self.launchSiteLon,self.dateAndTime)\n logger.debug('Fetched time zone data about the launch site: UTC offset is %f hours' % self.UTC_offset)\n\n self._UTC_time = self.dateAndTime - timedelta(seconds=self.UTC_offset * 3600)\n logger.debug('Using UTC time %s' % self._UTC_time.strftime('%d/%m/%y %H:%M'))\n\n ext = os.path.splitext(soundingFile)[1]\n assert(ext.lower() in ['.ftr', '.sounding']),\\\n 'Unknown sounding file format: {}. Should be .ftr or .sounding'.format(ext)\n\n # Try to open the file\n try:\n datastream = open(soundingFile, 'r')\n logger.debug('Sounding file successfully opened.')\n\n except IOError:\n logger.error('The sounding file you specified cannot be opened.')\n raise\n # Read it and split it in lines\n filelines = datastream.readlines()\n datastream.close()\n # Check that data exists\n assert(filelines), 'The sounding file is empty.'\n\n # Initialize variables\n PRESS = []\n HGHT = []\n TEMP = []\n DRCT = []\n SKNT = []\n\n if ext == '.ftr':\n # READ THE .FTR INPUT FILE AND PASS ITS DATA TO THE\n # process_sounding_data(...) METHOD.\n\n # Import data into variables\n filelines = filelines[1:] # Remove header\n for line in filelines:\n lineEntries = line.split()\n if len(lineEntries) == 12:\n PRESS.append(float(lineEntries[2]))\n HGHT.append(float(lineEntries[1]))\n TEMP.append(float(lineEntries[3]))\n DRCT.append(float(lineEntries[7]))\n SKNT.append(float(lineEntries[6]))\n\n logger.debug('Data imported.')\n progressHandler(0.5, 1)\n\n if self._process_sounding_data(PRESS, HGHT, TEMP, DRCT, SKNT):\n progressHandler(1.0, 1)\n self._weatherLoaded = True\n logger.debug('Weather successfully loaded.')\n else:\n self._weatherLoaded = False\n return\n\n\n elif ext == '.sounding':\n # READ THE .SOUNDING INPUT FILE AND PASS ITS DATA TO THE\n # process_sounding_data(...) METHOD.\n\n # Check that data exists\n if not filelines:\n logger.error('The sounding file you specified is empty.')\n return\n\n logger.debug('File reading completed.')\n\n # Detect first line of useful data\n startLine = 0\n for i in range(len(filelines)):\n if filelines[i][0] == '-' and i < 25:\n startLine = i + 1\n\n if startLine == 0:\n logger.error('Sounding file format does not follow format standards!')\n self._weatherLoaded = False\n\n # Import data into variables\n for line in filelines[startLine:]:\n try:\n data = line.split()\n if len(data) == 11:\n PRESS.append(float(data[0]))\n HGHT.append(float(data[1]))\n TEMP.append(float(data[2]))\n DRCT.append(float(data[6]))\n SKNT.append(float(data[7]))\n except ValueError:\n # End of useful data\n break\n\n logger.debug('Data imported.')\n\n if self._process_sounding_data(PRESS, HGHT, TEMP, DRCT, SKNT):\n self._weatherLoaded = True\n logger.debug('Weather successfully loaded.')\n else:\n self._weatherLoaded = False\n return","def loadascii(self, filename=None):\n data = np.loadtxt(filename)\n if len(data.shape) == 1:\n self.flux = data\n elif len(data.shape) == 2:\n self.wavelength = data[:,0]\n self.flux = data[:,1]","def read_all_signals(self):\n return [pio.sample(signal_idx)\n for signal_idx in self._signals_idx]","def load_info():\n data = np.loadtxt(\"u_sol_meta.txt\", dtype=int)\n return data","def read_data(cls, input_file,quotechar = None):\n if 'pkl' in str(input_file):\n lines = load_pickle(input_file)\n else:\n lines = input_file\n return lines","def load_sotu_data():\n sotu_files = glob.glob(\"sotu-data/*.txt\")\n path_desc = re.compile(r\"sotu-data/([A-Za-z]+)_([0-9]{4})\\.txt\")\n for filepath in sotu_files:\n with open(filepath, \"r\") as f:\n raw_text = f.read()\n pres, year = path_desc.search(filepath).groups()\n yield {\"president\": pres, \"year\": year, \"speech\": raw_text}","def __init__(self, raw_data_file,):\n self.raw_data_file = raw_data_file\n self.clean_data = self.cleanData()\n self.microtrip_data = []","def load_data(self, data_file):\n data = np.load(data_file)\n states = data['states']\n knack = data['knack']\n knack_kurtosis = data['knack_kurtosis']\n v = data['q_1_moment']\n\n extracted_data = {'states': states, 'v': normalize(v), 'knack': normalize(knack),\n 'knack_kurtosis': normalize(knack_kurtosis)}\n return extracted_data","def read(self):\n # open the .SPE file\n with open(self._input_file_path, 'rb') as f:\n lines = f.readlines()\n # Create an empty dictionary for the metadata\n metadata_dictionary = {}\n\n # Search through the file for the needed metadata\n metadata_dictionary['date_acquired'] = re.search(b'date=\"(.*?)\"', lines[1])[1].decode('ANSI') \n metadata_dictionary['width'] = int(re.search(b'width=\"(.*?)\"', lines[1])[1])\n metadata_dictionary['height'] = int(re.search(b'height=\"(.*?)\"', lines[1])[1])\n metadata_dictionary['size'] = metadata_dictionary['width']*metadata_dictionary['height']\n metadata_dictionary['exposure_time'] = int(re.search(b'<ExposureTime type=\"Double\">(.*?)</ExposureTime>', lines[1])[1])\n metadata_dictionary['excitation_wavelength'] = float(re.search(b'laserLine=\"(.*?)\"',lines[1])[1])\n metadata_dictionary['center_wavelength'] = float(re.search(b'<CenterWavelength type=\"Double\">(.*?)</CenterWavelength>',lines[1])[1])\n metadata_dictionary['orientation'] = re.search(b'orientation=\"(.*?)\"',lines[1])[1].decode('ANSI')\n\n # Get the wavelength and intensity\n wavelength_string = re.search(b'<Wavelength xml:space=\"preserve\">(.*?)</Wavelength>',lines[1])[1].decode('utf-8')\n wavelength = np.array(wavelength_string.split(','), dtype=np.float64)\n\n f.seek(4100)\n intensity = np.fromfile(f,dtype=np.float32,count=metadata_dictionary['size'])\n\n raman_shift_wavenumbers = 1e7*(1/metadata_dictionary['excitation_wavelength'] - 1/wavelength)\n\n f.close()\n \n # create the sidpy dataset\n data_set = Dataset.from_array(intensity, name='Raman Spectra')\n\n data_set.data_type = 'spectrum'\n data_set.units = 'counts'\n data_set.quantity = 'Intensity'\n\n # set dimensions\n data_set.set_dimension(0, Dimension(raman_shift_wavenumbers, name='Raman Shift',\n units = 'cm-1',\n quantity='Raman shift',\n dimension_type='spectral'))\n data_set.set_dimension(1, Dimension(intensity, name='Intensity',\n units = 'counts',\n quantity='intensity',\n dimension_type='spectral')) \n\n data_set.metadata = metadata_dictionary\n\n return data_set","def t8_loadFile(self):\n print \"spectrumFile\"\n filename = tkFileDialog.askopenfilename()\n filename = self.filenameparser(filename)\n self.t8_filename = filename","def read_process_song(path, window=1, overlap=0, debug=True):\n\n arr_features = []\n\n signal, sr = librosa.load(path)\n signal = signal[:660000]\n\n # Debug process\n if debug:\n print(\"Reading file: {}\".format(path))\n\n # Split songs:\n samples = split_songs(signal, window, overlap)\n\n # Append the result to the data structure\n for s in samples:\n features = get_features(s, sr)\n arr_features.append(features)\n return arr_features","def load_data():\n # Load in data\n sample_frame = energy_connection.sample_series('energy_readings')\n # TODO: Rooms/QL Extract\n sample_frame = energy_connection.sample_series('external_readings', append_frame=sample_frame)\n\n # To object\n sample = TimeSeriesSample(sample_frame, 'time')\n\n return sample","def __loadFromFile(self):\n fh = open(self.__fileName)\n for line in fh:\n if line.strip() == \" \":\n continue # we have an empty line, just skip\n sub = self.__createSubjectFromLine(line)\n # invoke the store method from the base class\n SubjectsRepo.store_subject(self, sub)\n fh.close()","def load_data_part(fname):\n if \"_data\" not in fname:\n return None\n # Read data\n data = pd.read_csv(fname)\n # events file\n events_fname = fname.replace('_data', '_events')\n # read event file\n labels = pd.read_csv(events_fname)\n clean = data.drop(['id'], axis=1) # remove id\n labels = labels.drop(['id'], axis=1) # remove id\n return clean, labels","def load_timestamps(timestamps_data_path):\n timestamp_file = os.path.join(\n timestamps_data_path, 'data.csv')\n\n timestamps = []\n with codecs.open(timestamp_file, 'r', 'utf-8') as f:\n for line in islice(f, 1, None):\n t = float(\"{:.9f}\".format(float(line.split(',')[0]) / 1e9))\n timestamps.append(t) \n\n # Subselect the chosen range of frames, if any\n return timestamps","def readFiles(self):\n #return a list of traces\n alltraces = []\n for dfile in self._datafiles:\n traces,headers = readgeonet(dfile)\n alltraces += traces\n return alltraces","def read_converted_pickle(picklefile, channel=0):\n\n with bz2.BZ2File(picklefile, \"rb\") as f:\n r = pickle.load(f)[channel]\n\n # r is now a list of dictionaries, one dict per trigger\n # convert the data to numpy arrays\n # and add a time key\n for i in range(len(r)):\n r[i]['data'] = np.array(r[i]['data'])\n r[i]['time'] = r[i]['timeStamp'] + \\\n np.arange(0., r[i]['data'].size / r[i]['samplingFreq'], 1. / r[i]['samplingFreq'])\n\n return r","def readData(self):\n f = open(self.filename)\n self.time = []\n self.data = []\n for line in f:\n if line.find('BAD FLAG') > 0:\n self.badValue = float(line.split(':')[1].strip())\n if line.find('LONGITUDE') > 0:\n self.lon = line.split(':')[1].strip()\n if line.find('LATITUDE') > 0:\n self.lat = line.split(':')[1].strip()\n if len(line) > 6 and line[2] == '-' and line[6] == '-':\n parts = line.rsplit(None, 1)\n # data line\n timeStamp = datetime.datetime.strptime(parts[0], '%d-%b-%Y %H')\n t = timeArray.datetimeToEpochTime(timeStamp)\n self.time.append(t)\n val = float(parts[1])\n self.data.append(val)\n\n self.time = np.array(self.time)\n self.data = np.array(self.data)\n # remove bad values\n if self.badValue:\n goodIx = self.data != self.badValue\n self.time = self.time[goodIx]\n self.data = self.data[goodIx]\n self.fileIsRead = True","def LoadTroikaDataset():\n data_dir = \"./datasets/troika/training_data\"\n data_fls = sorted(glob.glob(data_dir + \"/DATA_*.mat\"))\n ref_fls = sorted(glob.glob(data_dir + \"/REF_*.mat\"))\n return data_fls, ref_fls","def parse_lines_in_file(path):\n signals = []\n with open(path) as fp:\n for line in fp:\n # removes all text comments starting with # character\n parts = line.partition('#')\n line = parts[0]\n\n # removes starting and ending whitespace\n line = line.strip()\n if len(line) > 0:\n signals.append(line)\n return signals","def _load(self):\n\n # number of non-data header details at top of data file\n header = 1\n\n # open file\n weatherData = []\n with open(self.wfile) as myfile:\n if (self.lines > 0):\n weatherData = [next(myfile) for x in xrange(self.lines + header)]\n else:\n weatherData = myfile.readlines()\n\n # get data stream from first line\n streamHeader = weatherData.pop(0).rstrip()\n if (streamHeader == 'FULL'):\n self.dataStream = 0\n elif (streamHeader == 'ADVANCED'):\n self.dataStream = 1\n elif (streamHeader == 'BASIC'):\n self.dataStream = 2\n else:\n print \"Error: unecognised data stream from file %s\" % (self.wfile)\n return -1\n\n # read data\n inputData = []\n for line in weatherData:\n entries = line.split()\n inputData.append(entries)\n\n # copy all into np array\n self.data = np.array(inputData)\n\n return 0","def loadtrkfile(T_filename, threshold_short_streamlines=10.0):\r\n print(\"Loading %s\" % T_filename)\r\n T, hdr = trackvis.read(T_filename, as_generator=False)\r\n T = np.array([s[0] for s in T], dtype=np.object)\r\n \r\n\r\n \r\n return T","def read_data(path, low=275000, high=300000):\n data = read_pickle(path)\n\n Y1 = data['lowT_av'].squeeze()\n Y2 = data['upT_av'].squeeze()\n # LWC = data['lwc1V_av']\n X = np.arange(Y1.shape[0]) / 100.\n # X = data['time_av'].squeeze()\n if low is not None and high is not None:\n X = X[low:high]\n Y1 = Y1[low:high]\n Y2 = Y2[low:high]\n\n return X, Y1, Y2","def load_timestamps(self):\n print('Loading timestamps for sequence ' + self.sequence + '...')\n\n timestamp_file = os.path.join(self.sequence_path, 'times.txt')\n\n # Read and parse the timestamps\n self.timestamps = []\n with open(timestamp_file, 'r') as f:\n for line in f.readlines():\n t = dt.timedelta(seconds=float(line))\n self.timestamps.append(t)\n\n # Subselect the chosen range of frames, if any\n if self.frame_range:\n self.timestamps = [self.timestamps[i] for i in self.frame_range]\n\n print('Found ' + str(len(self.timestamps)) + ' timestamps...')\n\n print('done.')","def read_data(self, data_dir):\n\n # threshold for ZUPT ground truth\n sm_velocity_max_threshold = 0.004 # m/s\n\n f = os.path.join(self.predata_dir, 'urban06.p')\n if True and os.path.exists(f):\n return\n\n print(\"Start read_data, be patient please\")\n def set_path(seq):\n path_imu = os.path.join(data_dir, seq, \"sensor_data\",\n \"xsens_imu.csv\")\n path_gt = os.path.join(data_dir, seq, \"global_pose.csv\")\n return path_imu, path_gt\n\n time_factor = 1e9 # ns -> s\n\n def interpolate(x, t, t_int, angle=False):\n \"\"\"\n Interpolate ground truth with sensors\n \"\"\"\n x_int = np.zeros((t_int.shape[0], x.shape[1]))\n for i in range(x.shape[1]):\n if angle:\n x[:, i] = np.unwrap(x[:, i])\n x_int[:, i] = np.interp(t_int, t, x[:, i])\n return x_int\n\n sequences = os.listdir(data_dir)\n # read each sequence\n for sequence in sequences:\n print(\"\\nSequence name: \" + sequence)\n path_imu, path_gt = set_path(sequence)\n imu = np.genfromtxt(path_imu, delimiter=\",\")\n\n # Urban00-05 and campus00 have only quaternion and Euler data\n if not imu.shape[1] > 10:\n cprint(\"No IMU data for dataset \" + sequence, 'yellow')\n continue\n gt = np.genfromtxt(path_gt, delimiter=\",\")\n\n # time synchronization between IMU and ground truth\n t0 = np.max([gt[0, 0], imu[0, 0]])\n t_end = np.min([gt[-1, 0], imu[-1, 0]])\n\n # start index\n idx0_imu = np.searchsorted(imu[:, 0], t0)\n idx0_gt = np.searchsorted(gt[:, 0], t0)\n\n # end index\n idx_end_imu = np.searchsorted(imu[:, 0], t_end, 'right')\n idx_end_gt = np.searchsorted(gt[:, 0], t_end, 'right')\n\n # subsample\n imu = imu[idx0_imu: idx_end_imu]\n gt = gt[idx0_gt: idx_end_gt]\n t = imu[:, 0]\n\n # take ground truth position\n p_gt = gt[:, [4, 8, 12]]\n p_gt = p_gt - p_gt[0]\n\n # take ground matrix pose\n Rot_gt = torch.Tensor(gt.shape[0], 3, 3)\n for j in range(3):\n Rot_gt[:, j] = torch.Tensor(gt[:, 1 + 4 * j: 1 + 4 * j + 3])\n q_gt = SO3.to_quaternion(Rot_gt)\n # convert to angle orientation\n rpys = SO3.to_rpy(Rot_gt)\n t_gt = gt[:, 0]\n # interpolate ground-truth\n p_gt = interpolate(p_gt, t_gt, t)\n rpys = interpolate(rpys.numpy(), t_gt, t, angle=True)\n\n # convert from numpy\n ts = (t - t0)/time_factor\n p_gt = torch.Tensor(p_gt)\n rpys = torch.Tensor(rpys).float()\n q_gt = SO3.to_quaternion(SO3.from_rpy(rpys[:, 0], rpys[:, 1], rpys[:, 2]))\n imu = torch.Tensor(imu).float()\n\n # take IMU gyro and accelerometer and magnetometer\n imu = imu[:, 8:17]\n\n dt = ts[1:] - ts[:-1]\n # compute speed ground truth (apply smoothing)\n v_gt = torch.zeros(p_gt.shape[0], 3)\n for j in range(3):\n p_gt_smooth = savgol_filter(p_gt[:, j], 11, 1)\n v_j = (p_gt_smooth[1:] - p_gt_smooth[:-1]) / dt\n v_j_smooth = savgol_filter(v_j, 11, 0)\n v_gt[1:, j] = torch.Tensor(v_j_smooth)\n\n # ground truth specific motion measurement (binary)\n zupts = v_gt.norm(dim=1, keepdim=True) < sm_velocity_max_threshold\n zupts = zupts.float()\n # set ground truth consistent with ZUPT\n v_gt[zupts.squeeze() == 1] = 0\n\n # save for training\n mondict = {\n 'xs': zupts.float(),\n 'us': imu.float(),\n }\n pdump(mondict, self.predata_dir, sequence + \".p\")\n # save ground truth\n mondict = {\n 'ts': ts,\n 'qs': q_gt.float(),\n 'vs': v_gt.float(),\n 'ps': p_gt.float(),\n }\n pdump(mondict, self.predata_dir, sequence + \"_gt.p\")","def read(files, save):\n\t# NOTE all soundings are size obs long, they must be filled in with zeros for this data format...\n\t# create the HDF5 document\n\tdoc = h5(save)\n\tsize = 450 # this hopefully exceeds the size of the arrays # CPIN Files are much shorter...\n\tdoc.create(pres=size, temp=size, dewpt=size, rh=size, r=size, u=size, v=size, z=size, lat=1, lon=1, theta=size, thte=size,\n\t\twspd=size, wdir=size, gamma=size, stab=size, N=size, rich=size, thtdef=size, cpin=size)\n\t# those last two do not have to be included...\n\t# Z=geopotenital height\n\n\t# now read the files!\n\tfor f in sorted(files):\n\t\tfname = f.split('/')[-1]\n\t\t# if 'smth' not in fname and NCAR not in fname: continue\n\t\tl.info('reading ' + fname)\n\t\t# launch time comes from line 2 of the file, the last element\n\t\tdf = open(f, 'r')\n\t\ttxt = df.read(2000).split('\\n') # way more than we need\n\t\tdf.close()\n\t\tlatln = txt[0].split() # keys 1,2 will be what we want\n\t\ttry:\n\t\t\ttm = s2t(txt[1].split()[-1] + 'UTC', '%Y%m%d%H%M%Z')\n\t\texcept:\n\t\t\t# drat.\n\t\t\tprint txt.split('\\n')[1]\n\t\t\tcontinue\n\t\ttry:\n\t\t\tif 'cpin' in fname:\n\t\t\t\tz, p, t, td, rh, r, wb, tv, tht, thte, thtw, ws, wd, u, v, vflg, gamma, stab, N, rich, thtdef, cpin = np.loadtxt(f, skiprows=4, unpack=True)\n\t\t\t\t# r is mixing ratio\n\t\t\telse:\n\t\t\t\tz, p, t, td, rh, r, wb, tv, tht, thte, thtw, ws, wd, u, v, vflg, gamma, stab, N, rich = np.loadtxt(f, skiprows=4, unpack=True)\n\t\t\t\t# r is mixing ratio\n\t\texcept:\n\t\t\tl.warning('This file could not be read')\n\t\t\tcontinue\n\n\t\t# and append this data! I will trust the time seconds, instead of recomputing the time\n\t\t# but, before that, we have to make them all the same size - size long\n\t\tnl = np.zeros(size - t.shape[0]) - 999.00 # -999 array to fluff the end\n\t\tp = np.concatenate((p, nl))\n\t\tt = np.concatenate((t, nl))\n\t\ttd = np.concatenate((td, nl))\n\t\trh = np.concatenate((rh, nl))\n\t\tr = np.concatenate((r, nl))\n\t\ttv = np.concatenate((tv, nl))\n\t\ttht = np.concatenate((tht, nl))\n\t\tthte = np.concatenate((thte, nl))\n\t\tws = np.concatenate((ws, nl))\n\t\twd = np.concatenate((wd, nl))\n\t\tgamma = np.concatenate((gamma, nl))\n\t\tstab = np.concatenate((stab, nl))\n\t\tN = np.concatenate((N, nl))\n\t\trich = np.concatenate((rich, nl))\n\t\tu = np.concatenate((u, nl))\n\t\tv = np.concatenate((v, nl))\n\t\tz = np.concatenate((z, nl))\n\t\tif 'cpin' in fname:\n\t\t\tcpin = np.concatenate((cpin, nl))\n\t\t\tthtdef = np.concatenate((thtdef, nl))\n\t\t\tdoc.append(tm, persist=True, pres=p, temp=t, dewpt=td, rh=rh, r=r, u=u, v=v, z=z, lat=[latln[1]], lon=[latln[2]],\n\t\t\t\ttheta=tht, thte=thte, wspd=ws, wdir=wd, gamma=gamma, stab=stab, N=N, rich=rich, cpin=cpin, thtdef=thtdef)\n\t\telse:\n\t\t\tdoc.append(tm, persist=True, pres=p, temp=t, dewpt=td, rh=rh, r=r, u=u, v=v, z=z, lat=[latln[1]], lon=[latln[2]],\n\t\t\t\ttheta=tht, thte=thte, wspd=ws, wdir=wd, gamma=gamma, stab=stab, N=N, rich=rich)\n\tdoc.close()","def load(self, filename, build_hkl=True, load_instrument=False):\n with open(filename) as f:\n file_header = []\n for i, line in enumerate(f):\n if i == 0:\n _length = int(re.findall(r\"(?='(.*?)')\", line)[-2])\n [_m0, _prf] = [float(i) for i in re.findall(r\"(?='(.*?)')\", line)[-4].split()]\n if 'Q(x)' in line:\n args = line.split()\n col_headers = [head for head in args]\n break\n\n args = np.genfromtxt(filename, unpack=True, dtype=np.float64, skip_header=12)\n\n data = OrderedDict()\n for head, col in zip(col_headers, args):\n data[head] = col\n\n # add monitor column from header values\n data['monitor'] = np.empty(args[0].shape)\n data['monitor'].fill(_m0 * _prf)\n\n self._data = data\n self._file_header = file_header\n self.data_keys = {'detector': 'Counts', 'time': 'min', 'monitor': 'monitor'}\n\n if build_hkl:\n self.Q_keys = {'h': 'Q(x)', 'k': 'Q(y)', 'l': 'Q(z)', 'e': 'E', 'temp': 'T-act'}\n\n if load_instrument:\n instrument = Instrument()\n self.instrument = instrument","def load_data(data_file):\n # Load data from files\n data = list(codecs.open(data_file, \"r\", \"utf-8\").readlines())\n x_text = [\n [item for item in jieba.extract_tags(s, withWeight=False, topK=20, allowPOS=('n', 'v', 'nt', 'vn'))] for\n s in data]\n\n return x_text","def doImport(self, params):\n #logging.info(params.filename)\n raw_data = self.open_filename(params.filename)\n #logging.info('file open ok')\n data = self.split_to_blocks(raw_data)\n #logging.info('splitting ok')\n chromatograms = self.process_data_to_chromatograms(data)\n #logging.info('extract ok')\n \n processed_data = []\n \n zero = params.field_results[\"zero\"]\n MIC = params.field_results[\"MIC\"]\n TIC = params.field_results[\"TIC\"]\n round_MZ = params.field_results[\"round_MZ\"]\n \n for chrom in chromatograms:\n \n prefix = chrom['short_title']\n if (\".\" in prefix) and round_MZ:\n first,last = prefix.split('.')\n prefix = first\n \n if (\"MIC\" in prefix) and (not MIC):\n pass\n elif (\"TIC\" in prefix) and (not TIC):\n pass\n else:\n x = ImportDataset1D(name=prefix+'_time',data = chrom['time'])\n if zero:\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal_zero'])\n else:\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal'])\n processed_data.append(x)\n processed_data.append(y)\n \n return processed_data","def test_read_multiple_signals(self):\n cwd = os.path.dirname(os.path.abspath(__file__))\n test_dir = os.path.join(cwd, 'test_files/')\n signals = read_signals(test_dir)\n self.assertEqual(len(signals), 3)\n self.assertTrue(\n any(signal for signal in signals if signal.name == \"test1\"))\n self.assertTrue(\n any(signal for signal in signals if signal.name == \"test2\"))\n self.assertTrue(\n any(signal for signal in signals if signal.name == \"test3\"))","def load_cleaned_data(self):\n try:\n self.train = pd.read_pickle('../input/train_clean.pkl')\n self.test = pd.read_pickle('../input/test_clean.pkl')\n except FileNotFoundError:\n self.load_raw_data()","def __parse_file(self):\n\n if PY2:\n text = lambda v: v.decode('utf-8')\n else:\n text = lambda v: v\n with open(self._file, 'r') as csvfile:\n reader = csv.reader(csvfile, delimiter=';')\n for row in reader:\n try:\n siruta = int(row[0])\n except ValueError:\n self.__notify_error(\"Line %s has an invalid SIRUTA code\" % str(row))\n continue\n if not self.siruta_is_valid(siruta):\n self.__notify_error(\"SIRUTA code %d is not valid\" % siruta)\n if len(row) != 15:\n self.__notify_error(\"Line %s does not have 15 elements\" % str(row))\n continue\n if row[7] == \"1\":\n urban = True\n else:\n urban = False\n self._data[siruta] = {\n 'siruta': siruta,\n 'name': text(row[1]).translate(self._dia_trans),\n 'postcode': int(row[2]),\n 'county': int(row[3]),\n 'sirutasup': int(row[4]),\n 'type': int(row[5]),\n 'level': text(row[6]),\n 'urban': urban,\n 'region': int(row[8]),\n }","def loadtrkfile(T_filename, threshold_short_streamlines=10.0):\r\n print(\"Loading %s\" % T_filename)\r\n T, hdr = trackvis.read(T_filename, as_generator=False)\r\n T = np.array([s[0] for s in T], dtype=np.object)\r\n \r\n\r\n \r\n return T, hdr","def __read_data__(self):\n with open(self.file, 'r') as data:\n sentence = []\n tags = []\n for line in data:\n terms = line.rstrip().split(WHITESPACE)\n for term in terms:\n word_tag = tuple(term.split(TAGCHAR))\n word = word_tag[0]\n tag = word_tag[1]\n self.word_tag_dict[word_tag] += 1\n self.tag_dict[tag] += 1\n self.__add_to_word_dict__(word, tag)\n if self.isNumberWord(word):\n self.numbers += 1\n if word[0].isupper() and len(sentence) > 0:\n self.cap_no_start += 1\n sentence.append(word)\n tags.append(tag)\n if tag == ENDOFSENTENCE:\n self.sentences.append(tuple(sentence))\n self.tags.append(tuple(tags))\n sentence = []\n tags = []","def test_read_multiple_specified_signals(self):\n cwd = os.path.dirname(os.path.abspath(__file__))\n test_dir = os.path.join(cwd, 'test_files/')\n signals = read_signals(test_dir, ['test2', 'test3'])\n self.assertEquals(len(signals), 2)","def load_scitail(file, label_dict):\n rows = []\n cnt = 0\n with open(file, encoding=\"utf8\") as f:\n for line in f:\n blocks = line.strip().split('\\t')\n assert len(blocks) > 2\n if blocks[0] == '-': continue\n sample = {'uid': str(cnt), 'premise': blocks[0], 'hypothesis': blocks[1], 'label': label_dict[blocks[2]]}\n rows.append(sample)\n cnt += 1\n return rows","def parse(filepath):\n data = []\n\n with open(filepath, 'r') as file:\n line = next(file)\n while line:\n str_line = line.strip()\n if(str_line.startswith(\"Cell\")):\n dict_entry = {\n 'address': \"\",\n 'channel': \"\",\n 'frequency': \"\",\n 'quality': \"\",\n 'sLevel': \"\",\n 'essid': \"\"\n }\n dict_entry[\"address\"] = line.split(\": \")[1].strip()\n if(str_line.startswith(\"Channel\")):\n dict_entry[\"channel\"] = line.split(\":\")[1].strip()\n \n if(str_line.startswith(\"Frequency\")):\n reg_match = _RegExLib(str_line)\n dict_entry[\"frequency\"] = reg_match.frequency.group(1)\n\n \n\n if(str_line.startswith(\"Extra: Last beacon\")):\n data.append(dict_entry)\n \n \n\n line = next(file, None)\n\n return data","def test_load_gtis(self):\n fits_file = os.path.join(self.datadir, 'monol_testA.evt')\n hen.io.load_gtis(fits_file)","def _read_arasim_antenna_pickle(filename):\n # Quick fix for filenames with one of the approved extensions already\n # (just strip it)\n if filename.endswith(\".txt\") or filename.endswith(\".pkl\"):\n filename = filename[:-4]\n\n # If there is no pickle file, read the response data using the\n # _read_arasim_antenna_data function, and then make a pickle file\n if not os.path.isfile(filename+\".pkl\"):\n logger.warning(\"Antenna model file %s.pkl not found. \"+\n \"Generating a new file now\", filename)\n response_data = _read_arasim_antenna_data(filename+\".txt\")\n with open(filename+\".pkl\", 'wb') as f:\n pickle.dump(response_data, f)\n return response_data\n\n # Otherwise, read from the pickle file\n else:\n with open(filename+\".pkl\", 'rb') as f:\n return pickle.load(f)","def dataload():\n\t\n\tglobal A, B, fnA, fnB, lPcnA, lPcnB\n\t\n\tdwd = os.getcwd() # Data WD\n\t\t\n\t# First sample A is loaded. This is the \"calibrating\" sample.\n\t# In this case it is the OGLE III LMC small amplitude RGs.\n\t\n\tfnA = '/LMC-CalSample-cleaned_2.fits'\n\tA = Table.read(dwd+fnA)\n\n\t# Then sample B is loaded. For comparison/testing purposes, this is\n\t# again the OGLE III LMC SARGs.\n\t\n\tfnB = '/LMC-CalSample-cleaned_2.fits'\n\tB = Table.read(dwd+fnB)\n\t\n\t\"\"\" Fix tables so only the stars with all three good periods are \n\tconsidered. \"\"\"\n\t\n\tlPcnA = get_logPcn(A)\n\tlPcnB = get_logPcn(B)\n\t\n\tfor cn in lPcnA:\n\t\tA = A[A[cn]>0]\n\tfor cn in lPcnB:\n\t\tB = B[B[cn]>0]","def loadtcdat(filename= None):\n\n import numpy as np\n from StringIO import StringIO\n import Tkinter\n from tkFileDialog import askopenfilename\n from matplotlib.pyplot import figure,subplot,plot,xlabel,ylabel,title,legend\n\n if filename is not None:\n print \"Opening %s\\n\" %(filename)\n else:\n root = Tkinter.Tk()\n root.withdraw()\n filename = askopenfilename(parent=root, title='Open File',\n filetypes=[('csv files', '*.csv'),\n ('txt files', '*.txt')])\n root.destroy()\n root.mainloop()\n\n if filename is not None:\n f=open(filename)\n names = f.readline()\n names = names.strip('\\r\\n')\n names = names.split(\",\")\n f.close()\n\n data = np.genfromtxt(filename, delimiter=',',\n unpack=True, skip_header=2)\n time = data[0]\n\n figure()\n subplot(211)\n plot(time, data[1], label='Feed bin')\n plot(time, data[2], label='Part bin')\n ylabel(r'$ T_{bin} \\left(K\\right) $')\n legend(loc='best')\n\n subplot(212)\n plot(time,data[4],label='Feed bin heater')\n plot(time,data[5],label='Part bin heater')\n xlabel(r'$ Time \\left(s\\right) $')\n ylabel(r'$ P_{heater} \\left( \\frac{W}{m^2} \\right) $')\n legend(loc='best')\n\n return (data, time, names)"],"string":"[\n \"def load_signal_raw(filepath):\\n signal_raw = sio.loadmat(filepath)['signal_raw']\\n return signal_raw\",\n \"def _load_unlabeled(self, path):\\n signal, info = wfdb.rdsamp(path)\\n self.fs = 250\\n self.lead_match = ['anonymous1', 'anonymous2']\\n self.raw_data = np.transpose(np.array([signal]), (2, 0, 1))\\n self.symbol = []\\n self.coords = []\\n self.label_name = None\\n self._generate_beatlabel_from_estimation()\",\n \"def load_signal_file(self, path):\\n self.status.info()\\n try:\\n file_name = os.path.basename(path)\\n module_name, ext = os.path.splitext(file_name)\\n with open(path) as sig_file:\\n module = imp.load_source(module_name, path, sig_file)\\n except Exception:\\n self.status.error(\\\"Error reading '%s' signal file\\\" % file_name)\\n return\\n\\n for attr, obj in module.__dict__.items():\\n if isinstance(obj, type) and issubclass(obj, ogre.Signal):\\n sig = obj()\\n self.sig_list.append((attr, sig))\\n self.sig_frame.add(\\\"%s.%s\\\" % (module_name, attr))\\n\\n self.log_frame.log_import(module_name)\",\n \"def load_synthetic_data():\\n\\n pickle_object = FM().data_file \\n\\n with pickle_object.open('rb') as data_file: \\n return pickle.load(data_file)\",\n \"def load_signal(DS, sampling ):\\n my_db = ppg_db()\\n\\n file_records = list()\\n\\n # get all file in the Normal directory\\n folder_name = 'Normal/'\\n list_file = os.listdir(pathDB + folder_name)\\n list_file.sort()\\n\\n for file in list_file:\\n # check just file name\\n if file[0:4] in DS:\\n file_records.append(file)\\n\\n # get all file in the AF directory\\n folder_name = 'AF/'\\n list_file = os.listdir(pathDB + folder_name)\\n list_file.sort()\\n\\n for file in list_file:\\n #print(file[0:5])\\n if file[0:5] in DS:\\n file_records.append(file)\\n\\n # inialize variable\\n class_ID = [[] for i in range(len(DS))]\\n beat = [[] for i in range(len(DS))]\\n valid_R = [ np.array([]) for i in range(len(DS))]\\n\\n for myFile in range(0, len(file_records)):\\n print(\\\"Processing signal... \\\" + str(myFile) + \\\" / \\\" + str(len(file_records)) + \\\"...\\\")\\n\\n\\n # check is each file is named with Normal or AF\\n # print(file_records[myFile][0]) => N or A\\n if (file_records[myFile][0] == 'N'):\\n filename = pathDB + 'Normal/' + file_records[myFile]\\n print(\\\"file name \\\" + str(filename))\\n f = open(filename, 'rb')\\n reader = csv.reader(f, delimiter=',')\\n\\n RAW_signal_N = []\\n for row in reader:\\n # save signal to list\\n RAW_signal_N.append(float(row[0]))\\n\\n # iterate in signal\\n selectedSignal = []\\n for i in range(0,len(RAW_signal_N)):\\n selectedSignal.append(RAW_signal_N[i])\\n # sampling every 180 unit\\n if( i % (sampling-1) == 0 and i > 0 ):\\n beat[myFile].append(selectedSignal)\\n class_ID[myFile].append(0) # label the beat for Normal\\n selectedSignal = []\\n\\n\\n elif(file_records[myFile][0] == 'A'):\\n filename = pathDB + 'AF/' + file_records[myFile]\\n print(filename)\\n f = open(filename, 'rb')\\n reader = csv.reader(f, delimiter=',')\\n\\n RAW_signal_AF = []\\n for row in reader:\\n # save signal to list\\n RAW_signal_AF.append(float(row[0]))\\n\\n # iterate in signal\\n selectedSignal = []\\n for i in range(0, len(RAW_signal_AF)):\\n selectedSignal.append(RAW_signal_AF[i])\\n # sampling every 180 unit\\n if (i % (sampling - 1) == 0 and i > 0):\\n beat[myFile].append(selectedSignal)\\n class_ID[myFile].append(1) # label the beat for AF\\n selectedSignal = []\\n\\n print(\\\"Complete Load File\\\")\\n my_db.filename = file_records\\n my_db.beat = beat\\n my_db.class_ID = class_ID\\n\\n return my_db\",\n \"def updateSignals(self):\\n self.parser.read(self.file)\\n self.signalType = self.parser.get('Signals', 'signalType')\\n if self.signalType == 'single':\\n self.single = self.parser.get('Signals', 'single')\\n elif self.signalType == 'dual':\\n self.fast = self.parser.getint('Signals', 'fast')\\n self.slow = self.parser.getint('Signals', 'slow')\\n elif self.signalType == 'ribbon':\\n self.ribbonStart = self.parser.get('Signals', 'ribbonStart')\\n self.numRibbon = self.parser.get('Signals', 'numRibbon')\\n self.ribbonSpacing = self.parser.get('Signals', 'ribbonSpacing')\",\n \"def loadPulseData(filename, suffix = ''):\\n data = np.genfromtxt(filename+'.txt', skip_header=3, names=True,\\n dtype='i8,f8,S5,f8,f8,f8,f8,f8,f8')\\n print \\\"Importing...\\\\n\\\"\\n for key in data.dtype.fields.keys():\\n name = key + suffix\\n print name\\n globals()[name] = data[key]\",\n \"def loadFNIRS(self,filepath):\\r\\n self.tree = ET.parse(filepath)\\r\\n self.data = self.tree.getroot().find(\\\"data\\\")\\r\\n self.samplerate = float(self.tree.getroot().find('device').find('samplerate').text)\\r\\n self.sensors = [i.text for i in self.tree.getroot().find('columns')]\\r\\n self.sensorMask = [True]*len(self.sensors)\\r\\n self.measurements = len(self.tree.getroot().find('data'))\",\n \"def load_from_file(self, trfilename):\\n # Read the report file and populate the datastructure\\n for ll in open(trfilename):\\n timestr = ll.split()[0]\\n label = \\\" \\\".join(ll.split()[1:])\\n time = float(timestr)\\n\\n if label in (\\\"init-trigger\\\", \\\"trigger\\\"):\\n self.trtimes.append(time)\\n\\n elif label == \\\"sound-start\\\":\\n self.soundstarttime = time\\n\\n elif label == \\\"sound-stop\\\":\\n self.soundstoptime = time\\n\\n else:\\n self.otherlabels.append((time, label))\\n\\n # Fix weird TR times\\n itrtimes = np.diff(self.trtimes)\\n badtrtimes = np.nonzero(itrtimes > (itrtimes.mean()*1.5))[0]\\n newtrs = []\\n for btr in badtrtimes:\\n # Insert new TR where it was missing..\\n newtrtime = self.trtimes[btr]+self.expectedtr\\n newtrs.append((newtrtime, btr))\\n\\n for ntr, btr in newtrs:\\n self.trtimes.insert(btr+1, ntr)\",\n \"def load_data(path: str, keep_signals: AbstractSet[str] = None) -> List[SimData]:\\r\\n sim_datas = list()\\r\\n\\r\\n for file_name in sorted(os.listdir(path)):\\r\\n if not file_name.endswith(\\\".npy\\\"):\\r\\n continue\\r\\n file_name = file_name[:-4]\\r\\n\\r\\n try:\\r\\n signal, amplitude = file_name.split(\\\"_\\\")\\r\\n amplitude = float(amplitude)\\r\\n except ValueError:\\r\\n continue\\r\\n\\r\\n data = np.load(os.path.join(path, f\\\"{file_name}.npy\\\"))\\r\\n\\r\\n if keep_signals is None:\\r\\n vs = {n: data[n] for n in data.dtype.names if n != \\\"time\\\"}\\r\\n else:\\r\\n vs = {\\r\\n n: data[n]\\r\\n for n in data.dtype.names\\r\\n if n != \\\"time\\\" and n in keep_signals\\r\\n }\\r\\n\\r\\n sim_datas.append(\\r\\n SimData(\\r\\n signal=signal, amplitude=amplitude, time=data[\\\"time\\\"], vs=vs, fs=None\\r\\n )\\r\\n )\\r\\n\\r\\n return sim_datas\",\n \"def _load(self):\\n # Extract the ASCII header (5 first lines)\\n with open(self._xst_bin, 'rb') as f:\\n header = list(islice(f, 0, 5))\\n assert header[0] == b'HeaderStart\\\\n',\\\\\\n 'Wrong header start'\\n assert header[-1] == b'HeaderStop\\\\n',\\\\\\n 'Wrong header stop'\\n header = [s.decode('utf-8') for s in header]\\n hd_size = sum([len(s) for s in header])\\n\\n # Parse informations into a metadata dictionnary\\n keys = ['freq', 'ma', 'accu']\\n search = ['Freq.List', 'Mr.List', 'accumulation']\\n types = ['float64', 'int', 'int']\\n for key, word, typ in zip(keys, search, types):\\n for h in header:\\n if word in h:\\n self.meta[key] = np.array(\\n h.split('=')[1].split(','),\\n dtype=typ\\n )\\n\\n # Deduce the dtype for decoding\\n n_ma = self.meta['ma'].size\\n n_sb = self.meta['freq'].size\\n dtype = np.dtype(\\n [('jd', 'float64'),\\n ('data', 'complex64', (n_sb, n_ma*n_ma*2 + n_ma))]\\n )\\n\\n # Decoding the binary file\\n tmp = np.memmap(\\n filename=self._xst_bin,\\n dtype='int8',\\n mode='r',\\n offset=hd_size\\n )\\n decoded = tmp.view(dtype)\\n\\n self.data = decoded['data'] / self.meta['accu']\\n self.time = Time(decoded['jd'], format='jd', precision=0)\\n\\n return\",\n \"def load_data(self):\\n logging.debug('Loading data from file ({})...'.format(self.file_name))\\n parsed_data = list()\\n with open(self.file_name) as file_data:\\n for line in file_data.readlines():\\n temp = dict()\\n if 'JD' in line:\\n continue\\n line = line.split()\\n temp['ts'], temp['mag'], temp['dif'] = float(line[0][:14]), float(line[1]), float(line[2])\\n temp['f_mag'] = self.kalman_filter(temp['mag'])\\n temp['dt'] = self.jd_to_datetime(temp['ts'])\\n temp['dt_cor'] = self.jd_to_datetime(temp['ts'] - TIME_CRT)\\n parsed_data.append(temp)\\n logging.debug(' {} records loaded.'.format(len(parsed_data)))\\n logging.debug(parsed_data[0])\\n self.data_stream = parsed_data\",\n \"def _read_signals(edf_file, header):\\n signals = OrderedDict([(label, []) for label in header['label']])\\n\\n while True:\\n try:\\n record = _read_record(edf_file, header)\\n except EOFError:\\n break\\n\\n for label, signal in record.items():\\n signals[label].append(signal)\\n\\n for label, signal in signals.items():\\n signals[label] = np.concatenate(signal)\\n\\n return signals\",\n \"def load_list(self):\\n with open('/home/roman/Skola/ProjektyMimo/ApkaNaSkolu/output.dat', 'rb') as f:\\n self.events = pickle.load(f)\",\n \"def load_data(self) -> None:\",\n \"def load(filename):\\n root,ext = _os_path.splitext(filename)\\n loader = LOADER[ext]\\n frequency,raw_signal = loader(filename)\\n iinfo = _numpy.iinfo(raw_signal.dtype)\\n raw_signal_midpoint = (iinfo.max + iinfo.min)/2.\\n raw_signal_range = iinfo.max - raw_signal_midpoint\\n unit_output_signal = (raw_signal - raw_signal_midpoint)/raw_signal_range\\n return (frequency, unit_output_signal)\",\n \"def _load_qt(self, path):\\n signal, info = wfdb.rdsamp(path)\\n ann_1 = wfdb.rdann(path, extension='q1c')\\n ann_2 = wfdb.rdann(path, extension='qt1')\\n self.fs = 250\\n self.lead_match = ['anonymous1', 'anonymous2']\\n self.raw_data = np.transpose(np.array([signal]), (2, 0, 1))\\n self.symbol = [ann_1.symbol, ann_2.symbol]\\n self.coords = [ann_1.sample, ann_2.sample]\\n if list(np.unique(np.array(self.symbol[0]))) != ['(', ')', 'N', 'p', 't'] and list(np.unique(np.array(self.symbol[0]))) != ['(', ')', 'N', 'p', 't', 'u']:\\n print(\\\"Invalid symbols in ECG annotations.\\\")\\n raise ValueError\\n self.label_name = ['(', 'p', ')', '(', 'N', ')', 't', ')']\\n self._generate_beatlabel_from_label()\",\n \"def load_timestamps(data_path):\\n timestamp_file = os.path.join(data_path, 'oxts', 'timestamps.txt')\\n\\n # Read and parse the timestamps\\n timestamps = []\\n with open(timestamp_file, 'r') as f:\\n for line in f.readlines():\\n # NB: datetime only supports microseconds, but KITTI timestamps\\n # give nanoseconds, so need to truncate last 4 characters to\\n # get rid of \\\\n (counts as 1) and extra 3 digits\\n t = datetime.datetime.strptime(line[:-4], '%Y-%m-%d %H:%M:%S.%f')\\n timestamps.append(t)\\n return timestamps\",\n \"def load_data(self):\\n\\t\\ti = 0\\n\\n\\t\\tpaths = glob.glob(self.file_path+'/rollout_*')\\n\\t\\tself.rollouts = []\\n\\n\\n\\t\\tfor path in paths:\\n\\t\\t\\tdata_point = np.load(path,encoding='latin1')\\n\\t\\t\\tself.rollouts.append(data_point)\\n\\n\\t\\treturn paths\",\n \"def load_data():\\r\\n print ('Loadng all the file one time......')\\r\\n if not os.path.exists('cifar.pkl'):\\r\\n set_data()\\r\\n with open('cifar.pkl', 'rb') as cifar_pickle:\\r\\n data = six.moves.cPickle.load(cifar_pickle)\\r\\n return data\",\n \"def __parseStatechartSignalsH(self, file):\\n # Read file\\n f = open(file,\\\"r\\\")\\n lines = f.readlines()\\n #\\n event_lines = []\\n event_capture = False\\n event_dict = dict()\\n # Capture lines with user events\\n for line in lines:\\n if line.find(\\\"User defined signals\\\") > -1:\\n event_capture = True\\n if event_capture == True:\\n event_lines.append(line)\\n if line.find(\\\"Timer Events\\\") > -1\\\\\\n or line.find(\\\"Maximum signal id\\\") > -1\\\\\\n or line.find(\\\"State-Machine internal signals\\\") > -1:\\n break\\n # Make list of string event names and enum event values\\n event_lines = map(lambda x: x.strip(), event_lines[1:-1])[:-1]\\n event_names = map(lambda x: x.split(\\\",\\\")[0].strip(), event_lines)\\n x = map(lambda x: x.split(\\\",\\\")[1].split(\\\"/*\\\")[1].split(\\\"*/\\\")[0].strip(), event_lines)\\n event_nums = map(lambda x: int(x,16), x)\\n # Create the dictionary\\n for ev in enumerate(event_names):\\n event_dict[event_nums[ev[0]]] = ev[1]\\n #print ev\\n return event_dict\",\n \"def load_patient_data(db_dir, patient_id, include_labels=True, unzipped=False):\\n signal = load_signal(db_dir, patient_id, unzipped=unzipped)\\n if include_labels:\\n labels = load_labels(db_dir, patient_id, unzipped=unzipped)\\n return signal, labels\\n else:\\n return signal, None\",\n \"def readSigfile(filename):\\r\\n gtTrace = []\\r\\n gtTime = []\\r\\n gtHR = []\\r\\n with open(filename,'r') as f :\\r\\n x = f.readlines()\\r\\n s = x[0].split(' ')\\r\\n s = list(filter(lambda a:a != '',s))\\r\\n gtTrace = np.array(s).astype(np.float64)\\r\\n\\r\\n t = x[2].split(' ')\\r\\n t = list(filter(lambda a: a != '' ,t))\\r\\n gtTime = np.array(t).astype(np.float64)\\r\\n\\r\\n hr = x[1].split(' ')\\r\\n hr = list(filter(lambda a: a != '' ,hr))\\r\\n gtHR = np.array(hr).astype(np.float64)\\r\\n\\r\\n data = np.array(gtTrace)\\r\\n time = np.array(gtTime)\\r\\n hr = np.array(gtHR)\\r\\n\\r\\n return data,hr\",\n \"def load_data(self):\\n with open(self.file_name) as f:\\n lines = f.readlines()\\n\\n labels = list()\\n all_dat = list()\\n for i, l in enumerate(lines):\\n\\n labels.append(int(l[0]))\\n\\n l = gensim.utils.any2unicode(l)\\n all_dat.append(LabeledSentence(l.split(\\\"\\\\t\\\")[-1], [i]))\\n\\n return all_dat, np.asarray(labels)\",\n \"def loadSamples(filename):\\n data = []\\n with open(filename, encoding=\\\"utf-8\\\") as f_obj:\\n reader = csv.DictReader(f_obj, delimiter=';')\\n for line in reader:\\n Tetta = float(line['dTetta'])\\n Lambda = float(line['Lambda'])\\n item = TSample(Tetta, Lambda)\\n data.append(item)\\n return data\",\n \"def load_signal_data():\\n # Load images, annotations path\\n images = sorted(glob(IMAGES_PATH + '/*'))\\n annotations = sorted(glob(ANNOTATIONS_PATH + '/*'))\\n\\n patten = 'left'\\n left_images, right_image = [], []\\n left_annotations, right_annotations = [], []\\n for image, annotation in zip(images, annotations):\\n if len(re.findall(patten, image)):\\n left_images.append(image)\\n left_annotations.append(annotation)\\n else:\\n right_image.append(image)\\n right_annotations.append(annotation)\\n return left_images, right_image, left_annotations, right_annotations\",\n \"def data_clean_CWRU(self):\\r\\n\\r\\n os.chdir(self.path_txt)\\r\\n files, filelabesl_wc, filelabels_fs = self.filename_CWRU()\\r\\n\\r\\n signals = []\\r\\n for file in files:\\r\\n try:\\r\\n with open(file, \\\"r\\\") as fr:\\r\\n signal = fr.readlines()\\r\\n signal = np.array([float(item.strip()) for item in signal])\\r\\n except IOError:\\r\\n raise IOError(\\\"some wrong with the file %s\\\" % file)\\r\\n signals.append(signal.reshape(1, -1))\\r\\n\\r\\n os.chdir(self.path)\\r\\n return signals, filelabesl_wc, filelabels_fs\",\n \"def data_from_file(ta_file):\\n file_handle = open(ta_file, \\\"r\\\")\\n #\\n # We try to maintain read-compatibility with all versions of Turtle Art.\\n # Try pickle first; then different versions of json.\\n #\\n try:\\n _data = pickle.load(file_handle)\\n except:\\n # Rewind necessary because of failed pickle.load attempt\\n file_handle.seek(0)\\n _text = file_handle.read()\\n _data = data_from_string(_text)\\n file_handle.close()\\n return _data\",\n \"def load_data(self):\",\n \"def _load_ludb(self, path):\\n signal, info = wfdb.rdsamp(path)\\n self.fs = 500\\n self.lead_match = ['I', 'II', 'III', 'aVR', 'aVL', 'aVF', 'V1', 'V2', 'V3', 'V4', 'V5', 'V6']\\n self.raw_data = np.transpose(np.array([signal]), (2, 0, 1))\\n self.symbol = []\\n self.coords = []\\n for lead in ['i', 'ii', 'iii', 'avr', 'avl', 'avf', 'v1', 'v2', 'v3', 'v4', 'v5', 'v6']:\\n ann_ii = wfdb.rdann(path, extension='atr_{}'.format(lead))\\n symbol_1 = ann_ii.symbol\\n coords_1 = ann_ii.sample\\n if list(np.unique(np.array(symbol_1))) != ['(', ')', 'N', 'p', 't'] and list(np.unique(np.array(symbol_1))) != ['(', ')', 'N', 'p', 't', 'u']:\\n print(\\\"Invalid symbols in ECG annotations.\\\")\\n raise ValueError\\n self.symbol.append(symbol_1)\\n self.coords.append(coords_1)\\n self.label_name = ['(', 'p', ')', '(', 'N', ')', '(', 't', ')']\\n self._generate_beatlabel_from_label()\",\n \"def load_data(self) -> None:\\n self.paths: List[str] = []\\n self.durations: List[float] = []\\n self.transcriptions: List[str] = []\\n\\n def raise_(err):\\n \\\"\\\"\\\"raises error if problem during os.walk\\\"\\\"\\\"\\n raise err\\n\\n for subset in self.subsets:\\n subset_path = os.path.join(self.root, self.base_dir, subset)\\n for root, dirs, files in os.walk(subset_path, onerror=raise_):\\n if not files:\\n continue\\n matches = fnmatch.filter(files, \\\"*.trans.txt\\\")\\n assert len(matches) == 1, \\\"> 1 transcription file found\\\"\\n self._parse_transcription_file(root, matches[0])\\n\\n self._sort_by_duration()\",\n \"def read_raw_data(self):\\n dat_file = os.path.join(DATA_DIR, self.patient_number + '.txt')\\n if not os.path.exists(dat_file):\\n raise AssertionError(\\\"{} doesn't exist.\\\".format(dat_file))\\n time = []\\n voltage1 = []\\n voltage2 = []\\n with open(dat_file, 'r') as fd:\\n for line in fd:\\n line = line.split()\\n time.append(line[0])\\n voltage1.append(float(line[1]))\\n voltage2.append(float(line[2]))\\n\\n tags_file = os.path.join(DATA_DIR, self.patient_number + '_tag.txt')\\n if not os.path.exists(dat_file):\\n raise AssertionError(\\\"{} doesn't exist.\\\".format(tags_file))\\n tags_time = []\\n tags = []\\n r_peaks_indexes = []\\n with open(tags_file, 'r') as fd:\\n for line in fd:\\n line = line.split()\\n tags_time.append(line[0])\\n tags.append(line[2])\\n r_peaks_indexes.append(int(line[1]))\\n return time, voltage1, voltage2, tags_time, tags, r_peaks_indexes\",\n \"def load(filename):\\r\\n wholeTract= nib.streamlines.load(filename) \\r\\n wholeTract = wholeTract.streamlines\\r\\n return wholeTract\",\n \"def read(self, filename=None, **kwargs):\\n \\n # --- Standard tests and exceptions (generic code)\\n if filename:\\n self.filename = filename\\n if not self.filename:\\n raise Exception('No filename provided')\\n if not os.path.isfile(self.filename):\\n raise OSError(2,'File not found:',self.filename)\\n if os.stat(self.filename).st_size == 0:\\n raise EmptyFileError('File is empty:',self.filename)\\n try:\\n from nptdms import TdmsFile\\n except:\\n raise Exception('Install the library nptdms to read this file')\\n\\n fh = TdmsFile(self.filename, read_metadata_only=False)\\n # --- OLD, using some kind of old version of tdms and probably specific to one file\\n # channels_address = list(fh.objects.keys())\\n # channels_address = [ s.replace(\\\"'\\\",'') for s in channels_address]\\n # channel_keys= [ s.split('/')[1:] for s in channels_address if len(s.split('/'))==3]\\n # # --- Setting up list of signals and times\\n # signals=[]\\n # times=[]\\n # for i,ck in enumerate(channel_keys):\\n # channel = fh.object(ck[0],ck[1])\\n # signals.append(channel.data)\\n # times.append (channel.time_track())\\n\\n # lenTimes = [len(time) for time in times]\\n # minTimes = [np.min(time) for time in times]\\n # maxTimes = [np.max(time) for time in times]\\n # if len(np.unique(lenTimes))>1:\\n # print(lenTimes)\\n # raise NotImplementedError('Different time length') \\n # # NOTE: could use fh.as_dataframe\\n # if len(np.unique(minTimes))>1:\\n # print(minTimes)\\n # raise NotImplementedError('Different time span') \\n # if len(np.unique(maxTimes))>1:\\n # print(maxTimes)\\n # raise NotImplementedError('Different time span') \\n # # --- Gathering into a data frame with time\\n # time =times[0]\\n # signals = [time]+signals\\n # M = np.column_stack(signals)\\n # colnames = ['Time_[s]'] + [ck[1] for ck in channel_keys]\\n # self['data'] = pd.DataFrame(data = M, columns=colnames)\\n # --- NEW\\n self['data'] = fh\\n\\n #for group in fh.groups():\\n # for channel in group.channels():\\n # #channel = group['channel name']\\n # print('Group:',group.name , 'Chan:',channel.name)\\n # channel_data = channel[:]\\n # if len(channel_data)>0:\\n # print(' ', type(channel_data))\\n # #print(' ', len(channel_data))\\n # print(' ', channel_data)\\n # print(' ', channel_data[0])\\n # try:\\n # print(channel.time_track())\\n # except KeyError:\\n # print('>>> No time track')\",\n \"def load(self):\\n path = self.directory + \\\"/\\\" + self.filename\\n dictionary = pickle.load(open(path, 'rb'))\\n self.coefficients = dictionary[\\\"coefficients\\\"]\\n self.display = dictionary[\\\"display\\\"]\\n self.construction = dictionary[\\\"construction\\\"]\\n self.drawing = dictionary[\\\"drawing\\\"]\\n self.updateSample()\\n self.context.console.append(\\\"The Fourier components are loaded.\\\")\",\n \"def read_probes(files, noisy=False, locations=False, datetimes=False):\\n\\n if len(files) == 0:\\n raise Exception('No files provided.')\\n\\n if not isinstance(files, (list, tuple)):\\n files = [files]\\n\\n for i, file in enumerate(files):\\n if noisy:\\n print('Loading file {} of {}...'.format(i + 1, len(files)), end=' ')\\n\\n # Get the header so we can extract the position data.\\n with open(file, 'r') as f:\\n # Latitude and longitude is stored at line 15 (14 in sPpython\\n # counting). Eastings and northings are at 13 (12 in Python\\n # indexing).\\n lonlatz = [float(pos.strip()) for pos in filter(None, f.readlines()[14].split(' '))]\\n\\n data = np.genfromtxt(file, skip_header=18)\\n\\n if i == 0:\\n try:\\n times = data[:, 0]\\n values = data[:, 1:]\\n except IndexError:\\n times = data[0]\\n values = data[1:]\\n positions = lonlatz\\n else:\\n try:\\n times = np.hstack((times, data[:, 0]))\\n values = np.vstack((values, data[:, 1:]))\\n except IndexError:\\n times = np.hstack((times, data[0]))\\n values = np.vstack((values, data[1:]))\\n\\n positions = np.vstack((positions, lonlatz))\\n\\n if noisy:\\n print('done.')\\n\\n if datetimes:\\n times = num2date(times, \\\"days since 1858-11-17 00:00:00\\\")\\n\\n # It may be the case that the files have been supplied in a random order,\\n # so sort the values by time here.\\n sidx = np.argsort(times)\\n times = times[sidx]\\n values = values[sidx, ...] # support both 1 and 2D data\\n\\n if locations:\\n return times, values, positions\\n else:\\n return times, values\",\n \"def convert(filename, signal=sampleArray(), \\n centerEta = DEFCENTERETA, centerPhi = DEFCENTERPHI): \\n numEvents = 0\\n listOfSignals = []\\n # First we open the file\\n with open(filename, \\\"r\\\") as f:\\n content = f.readlines()\\n numEvents = len(content)\\n for i in range(0, numEvents):\\n if i % 1000 == 0:\\n print(i)\\n thisEvent = content[i]\\n try:\\n reducedEvent = convertEvent(\\n thisEvent, centerEta, centerPhi, signal.shape[0], signal.shape[1]\\n ) \\n listOfSignals.append(reducedEvent)\\n except indexError:\\n 0\\n print(\\\"Converted\\\", len(listOfSignals), \\\"out of\\\", numEvents, \\\"events\\\")\\n return listOfSignals\",\n \"def read_syn_data():\\n dipy_home = pjoin(os.path.expanduser('~'), '.dipy')\\n folder = pjoin(dipy_home, 'syn_test')\\n t1_name = pjoin(folder, 't1.nii.gz')\\n b0_name = pjoin(folder, 'b0.nii.gz')\\n\\n md5_dict = {'t1': '701bda02bb769655c7d4a9b1df2b73a6',\\n 'b0': 'e4b741f0c77b6039e67abb2885c97a78'}\\n\\n check_md5(t1_name, md5_dict['t1'])\\n check_md5(b0_name, md5_dict['b0'])\\n\\n t1 = nib.load(t1_name)\\n b0 = nib.load(b0_name)\\n return t1, b0\",\n \"def _read_arasim_antenna_data(filename):\\n data = {}\\n freqs = set()\\n thetas = set()\\n phis = set()\\n freq = 0\\n with open(filename) as f:\\n for line in f:\\n words = line.split()\\n if line.startswith('freq'):\\n freq = 1\\n if words[-1]==\\\"Hz\\\":\\n pass\\n elif words[-1]==\\\"kHz\\\":\\n freq *= 1e3\\n elif words[-1]==\\\"MHz\\\":\\n freq *= 1e6\\n elif words[-1]==\\\"GHz\\\":\\n freq *= 1e9\\n else:\\n raise ValueError(\\\"Cannot parse line: '\\\"+line+\\\"'\\\")\\n freq *= float(words[-2])\\n freqs.add(freq)\\n elif line.startswith('SWR'):\\n swr = float(words[-1])\\n elif len(words)==5 and words[0]!=\\\"Theta\\\":\\n theta = int(words[0])\\n thetas.add(theta)\\n phi = int(words[1])\\n phis.add(phi)\\n db_gain = float(words[2])\\n # AraSim actually only seems to use the sqrt of the gain\\n # (must be gain in power, not voltage)\\n # gain = np.sqrt(float(words[3]))\\n gain = np.sqrt(10**(db_gain/10))\\n phase = np.radians(float(words[4]))\\n data[(freq, theta, phi)] = (gain, phase)\\n\\n # Convert data dictionary into 3-D array of responses\\n response = np.empty((len(freqs), len(thetas), len(phis)),\\n dtype=np.complex_)\\n for i, freq in enumerate(sorted(freqs)):\\n for j, theta in enumerate(sorted(thetas)):\\n for k, phi in enumerate(sorted(phis)):\\n gain, phase = data[(freq, theta, phi)]\\n response[i, j, k] = gain * np.exp(1j*phase)\\n\\n response_data = (response, np.array(sorted(freqs)),\\n np.array(sorted(thetas)), np.array(sorted(phis)))\\n return _fix_response_wrapping(response_data)\",\n \"def load_signal(db_dir, patient_id, unzipped=False, mmap_mode=None):\\n if unzipped:\\n signal = np.load(os.path.join(db_dir, '{:05d}_batched.npy'.format(patient_id)), mmap_mode=mmap_mode)\\n else:\\n signal = load_pkl(os.path.join(db_dir, '{:05d}_batched.pkl.gz'.format(patient_id)))\\n return signal\",\n \"def __parse(self):\\n lines = self.file.readlines()\\n for i in range(0, len(lines)):\\n line = lines[i]\\n tokens = line.split()\\n if tokens[0] == \\\"#start\\\":\\n trial_name = tokens[1]\\n trial = Trial(trial_name)\\n self.trials[trial_name] = trial\\n elif tokens[0] == \\\"#end\\\":\\n continue\\n else:\\n date_str = tokens[0] + \\\" \\\" + tokens[1]\\n date = datetime.strptime(date_str, \\\"%m/%d/%y %H:%M:%S\\\")\\n sound_file = line[18:-1].strip()\\n event = Event(date, sound_file, 0)\\n trial.addevent(event)\",\n \"def load_ICA_data(subject, data_dir, file='post_ICA', preload=True):\\n\\tDS_dir = 'downsampled_128'\\n\\t#datadir='/Users/md42732/Desktop/data/EEG/MovieTrailers/Participants/%s/%s'%(subject, DS_dir)\\n\\tif file == 'post_ICA':\\n\\t\\tds = io.read_raw_fif('%s/%s/%s/%s_postICA_rejected.fif'%(data_dir, subject, DS_dir, subject), preload=True)\\n\\telse:\\n\\t\\tprint('No other file previously saved to load')\\n\\n\\treturn ds\",\n \"def _from_file(self, path):\\r\\n\\r\\n file = pathlib.Path(path)\\r\\n log.info(\\\"Extracting data from file: {}\\\".format(file))\\r\\n\\r\\n with open(file, 'r') as f:\\r\\n lines = f.readlines()\\r\\n\\r\\n self._extract_raw_data(lines)\\r\\n\\r\\n return\",\n \"def t7_loadFile(self):\\n print \\\"subspectrumFile\\\"\\n filename = tkFileDialog.askopenfilename()\\n filename = \\\"SubSpectrumData/\\\" + self.filenameparser(filename)\\n self.t7_filename = filename\",\n \"def t1_loadFile(self):\\n print \\\"subspectrumFile\\\"\\n filename = tkFileDialog.askopenfilename()\\n filename = self.filenameparser(filename)\\n self.t1_filename = filename\",\n \"def spectre_tsv3(f):\\n \\n skip = 0\\n while True:\\n try: \\n wav, flux, dflux = np.loadtxt(f, skiprows = skip, unpack = True)\\n \\n except ValueError:\\n # Si les première lignes ont un en-tête\\n skip += 1\\n \\n else:\\n break\\n \\n return wav,flux\",\n \"def t9_loadFile(self):\\n print \\\"subspectrumFile\\\"\\n filename = tkFileDialog.askopenfilename()\\n filename = \\\"SubSpectrumData/\\\" + self.filenameparser(filename)\\n orgin_file = self.filenameparser(filename)\\n self.t9_filename = filename\\n self.t9_orginfilename = orgin_file\",\n \"def read_wavetxt(path):\\n with open(path) as f:\\n for line in f.readlines():\\n line = line.strip()\\n if 'SampleFrequence' in line:\\n freq = int(line[16:])\\n elif 'DataInput' in line:\\n series = np.array(line[10:].split(',')).astype(np.float64)\\n return (freq, series)\",\n \"def _read_record(edf_file, header):\\n labels = header['label']\\n signals = OrderedDict()\\n\\n for channel in range(header['num_signals']):\\n num_bytes = _bytes_per_record(channel, header)\\n raw_bytes = edf_file.read(num_bytes)\\n if not len(raw_bytes) == num_bytes:\\n raise EOFError('Could not read a full record.')\\n\\n digital = np.fromstring(raw_bytes, _RAW_INT_FORMAT).astype(np.float)\\n physical = _dig_to_phys(digital, channel, header)\\n signals[labels[channel]] = physical\\n\\n return signals\",\n \"def load(fnames, tag=None, inst_id=None):\\n\\n if not fnames:\\n print('fnames are go')\\n warnings.warn('You no got no fname, you no get no data')\\n return pysat.DataFrame(None), pysat.Meta(None)\\n elif len(fnames) == 1:\\n print('fnames are greater than 1')\\n meta = pysat.Meta()\\n signal_meta = pysat.Meta()\\n\\n # load the rinex\\n data = gr.load(fnames[0])\\n # get the metadata from the xarray.Dataset\\n xr_attrs = data.attrs\\n # format the metadata\\n# for at in xr_attrs:\\n# print(type(at))\\n# meta[at] = {'units': '', 'long_name': at}\\n# keys = data.data_vars.keys()\\n# for key in keys:\\n# # find the xarray equivalents of units and long_name\\n# print(key)\\n# signal_meta[key] = {meta.labels.units: var_units[key][0],\\n# meta.labels.name: var_units[key][1]}\\n# # format the data\\n# meta['signals'] = signal_meta\\n# output = data.variables\\n return data, meta\\n else:\\n raise ValueError('Only one filename currently supported')\\n print('no idea wahts goin on')\",\n \"def load_data():\\n\\n dump_path = dump_base + '/micro_poi/mpoi_info/'\\n\\n assert os.path.exists(dump_path)\\n\\n dpath = dump_path + 'shortest_path.pickle'\\n paths = joblib.load(dpath)\\n\\n dpath = dump_path + 'path_list.pickle'\\n path_list = joblib.load(dpath)\\n\\n dpath = dump_path + 'gain.pickle'\\n gain = joblib.load(dpath)\\n\\n dpath = dump_path + 'stay.pickle'\\n stay_time = joblib.load(dpath)\\n\\n dpath = dump_path + 'reach.pickle'\\n reach_time = joblib.load(dpath)\\n\\n spath = dump_base + '/micro_poi/model_params.list'\\n model_params = np.loadtxt(spath)\\n\\n return np.array(paths), path_list, gain, stay_time, reach_time, model_params\",\n \"def test_load_gtis(self):\\n fname = os.path.join(datadir, 'monol_testA.evt')\\n load_gtis(fname, gtistring=\\\"GTI\\\")\",\n \"def load_data(filename):\\n hkas = HKArchiveScanner()\\n hkas.process_file(filename)\\n cat = hkas.finalize()\\n fields, timelines = cat.get_data(['position'], short_match=True)\\n return fields, timelines\",\n \"def loadData(self,filepath):\\r\\n self.removeCheckbuttons()\\r\\n self.tree = ET.parse(filepath)# Parse xml Tree\\r\\n self.data = self.tree.getroot().find(\\\"data\\\")# Find Data\\r\\n self.sensors = [i.text for i in self.tree.getroot().find('columns')]# Get Sensor Names\\r\\n for s in self.sensors:# Add Each Sensor as Option\\r\\n self.addOption(s)\",\n \"def spectre_tsv(f):\\n \\n skip = 0\\n while True:\\n try: \\n wav, flux = np.loadtxt(f, skiprows = skip, unpack = True)\\n \\n except ValueError:\\n # Si les première lignes ont un en-tête\\n skip += 1\\n \\n else:\\n break\\n \\n return wav,flux\",\n \"def extract_from_file(self, data_file, data_path):\\n with open(data_file, \\\"r\\\") as f:\\n lines = f.readlines()\\n\\n # Add the complete path to each file name so that we can\\n # properly load them into the CHOPPER\\n data_paths = [os.path.join(data_path, line) for line in lines]\\n\\n spect_file_pairs = []\\n for path in data_paths:\\n # Use the file family to easily get the names of the different\\n # file types!\\n file_family = FileFamily(path)\\n\\n # Append tuple with (spect_file, label_mask_file)\\n spect_file_pairs.append((file_family.fullpath(AudioType.SPECTRO), file_family.fullpath(AudioType.MASK)))\\n\\n return spect_file_pairs\",\n \"def parse_file(self, file_path) -> list:\\n data = []\\n with open(file_path, 'rb') as f:\\n lines = pickle.load(f)\\n for line in lines:\\n input, output = line\\n if input.strip() == \\\"\\\" or output.strip() == \\\"\\\":\\n continue\\n input_len = len(input.split())\\n output_len = len(output.split())\\n if input_len > 50 or output_len > 50:\\n continue\\n data_item = Text2TextDataItem(input_text=input, output_text=output, tokenizer=self.tokenizer,\\n share_vocab=self.share_vocab)\\n data.append(data_item)\\n return data\",\n \"def entries_from_goes_ts_files(*files, default_waveunit=None, source=None):\\n\\n\\n \\\"\\\"\\\"\\n ts_goes = ts.TimeSeries(file)\\n statinfo = os.stat(file)\\n entry = DatabaseEntry(path=file)\\n entry.size = statinfo.st_size\\n\\n #header['INSTRUME'] = header['TELESCOP']# So E.G. 'GOES 6' instead 'X-ray Detector'\\n entry.instrument = ts_goes.meta.get('TELESCOP').values()\\n entry.instrument = ts_goes.meta.get('TELESCOP').values()\\n\\n entry.wavemax = 0.8 # XRSB '1.0--8.0 $\\\\AA$'\\n entry.wavemin = 0.05 # XRSA '0.5--4.0 $\\\\AA$'\\n\\n #\\n entry.observation_time_start = ts_goes.meta.get('date-beg').values()[0]\\n entry.observation_time_end = ts_goes.meta.get('date-end').values()[0]\\n\\n entry.metadata = ts_goes.meta.metadata[0][2]\\n\\n #entry.tags = [ sunpy.database.attrs.Tag('raw') ]\\n \\\"\\\"\\\"\\n\\n\\n for file in files:\\n headers = fits.get_header(file)\\n if isinstance(file, (str, six.text_type)):\\n filename = file\\n else:\\n filename = getattr(file, 'name', None)\\n statinfo = os.stat(file)\\n #print('a header')\\n entry = DatabaseEntry(path=filename)\\n entry.size = statinfo.st_size\\n\\n # Add/tweak start/end entries for GOES\\n if headers[0].get('TELESCOP','') != '':\\n #header['INSTRUME'] = header['TELESCOP']# So E.G. 'GOES 6' instead 'X-ray Detector'\\n entry.instrument = headers[0]['TELESCOP']\\n elif headers[1].get('TELESCOP','') != '':\\n entry.instrument = headers[1]['TELESCOP']\\n if (headers[0].get('DATE-OBS','') != ''):\\n if is_time_in_given_format(headers[0]['DATE-OBS'], '%d/%m/%Y'):\\n start_time = datetime.strptime(headers[0]['DATE-OBS'], '%d/%m/%Y')\\n elif is_time_in_given_format(headers[0]['DATE-OBS'], '%d/%m/%y'):\\n start_time = datetime.strptime(headers[0]['DATE-OBS'], '%d/%m/%y')\\n else:\\n start_time = parse_time(headers[0]['DATE-OBS'])\\n elif (headers[1].get('DATE-OBS','') != ''):\\n if is_time_in_given_format(headers[1]['DATE-OBS'], '%d/%m/%Y'):\\n start_time = datetime.strptime(headers[1]['DATE-OBS'], '%d/%m/%Y')\\n elif is_time_in_given_format(headers[1]['DATE-OBS'], '%d/%m/%y'):\\n start_time = datetime.strptime(headers[1]['DATE-OBS'], '%d/%m/%y')\\n else:\\n start_time = parse_time(headers[1]['DATE-OBS'])\\n\\n if (headers[0].get('DATE-END','') != ''):\\n if is_time_in_given_format(headers[0]['DATE-END'], '%d/%m/%Y'):\\n end_time = datetime.strptime(headers[0]['DATE-END'], '%d/%m/%Y')\\n elif is_time_in_given_format(headers[0]['DATE-END'], '%d/%m/%y'):\\n end_time = datetime.strptime(headers[0]['DATE-END'], '%d/%m/%y')\\n else:\\n end_time = parse_time(headers[0]['DATE-END'])\\n elif (headers[1].get('DATE-END','') != ''):\\n if is_time_in_given_format(headers[1]['DATE-END'], '%d/%m/%Y'):\\n end_time = datetime.strptime(headers[1]['DATE-END'], '%d/%m/%Y')\\n elif is_time_in_given_format(headers[1]['DATE-END'], '%d/%m/%y'):\\n end_time = datetime.strptime(headers[1]['DATE-END'], '%d/%m/%y')\\n else:\\n end_time = parse_time(headers[1]['DATE-END'])\\n else:\\n end_time = start_time + timedelta(days=1,seconds=-1)\\n\\n # Add these to the entry\\n entry.observation_time_start = start_time\\n entry.observation_time_end = end_time\\n\\n entry.wavemax = 0.8 # XRSB '1.0--8.0 $\\\\AA$'\\n entry.wavemin = 0.05 # XRSA '0.5--4.0 $\\\\AA$'\\n\\n if source:\\n entry.source = source\\n\\n entry.metadata = MetaDict(headers[1])\\n #entry.tags = sunpy.database.attrs.Tag('raw')\\n\\n #entry = DatabaseEntry(instrument='EIT', wavemin=25.0)\\n\\n #return entry\\n yield entry\",\n \"def readData(pulse_dir, label_filename, data_description):\\n print('=' * 20, \\\"reading in data...\\\", '=' * 20)\\n global Subject\\n\\n # Modify the root directory of pulse data in Subject\\n Subject.pulse_dir = pulse_dir\\n\\n # Read the label file\\n label_file = pd.read_excel(label_filename)\\n subject_names = label_file['subject'].dropna().values\\n\\n subject_list = []\\n for i in range(len(subject_names)):\\n try:\\n subject_list.append(\\n Subject(subject_names[i], label_df=label_file.iloc[i * 20:(i + 1) * 20:, 1:], data_description=data_description))\\n except Exception as e:\\n print(\\\"Exeception in data.py\\\")\\n print(e)\\n\\n print('=' * 20, \\\"All valid data are read\\\", '=' * 20)\\n return subject_list, subject_names\",\n \"def load(self, progressHandler=None):\\n soundingFile = self.soundingFile\\n\\n # create a null handler if input progressHandler is None:\\n if not progressHandler:\\n def progressHandler(*args):\\n return None\\n\\n if self.UTC_offset == 0:\\n self.UTC_offset = tools.getUTCOffset(self.launchSiteLat,\\n self.launchSiteLon,self.dateAndTime)\\n logger.debug('Fetched time zone data about the launch site: UTC offset is %f hours' % self.UTC_offset)\\n\\n self._UTC_time = self.dateAndTime - timedelta(seconds=self.UTC_offset * 3600)\\n logger.debug('Using UTC time %s' % self._UTC_time.strftime('%d/%m/%y %H:%M'))\\n\\n ext = os.path.splitext(soundingFile)[1]\\n assert(ext.lower() in ['.ftr', '.sounding']),\\\\\\n 'Unknown sounding file format: {}. Should be .ftr or .sounding'.format(ext)\\n\\n # Try to open the file\\n try:\\n datastream = open(soundingFile, 'r')\\n logger.debug('Sounding file successfully opened.')\\n\\n except IOError:\\n logger.error('The sounding file you specified cannot be opened.')\\n raise\\n # Read it and split it in lines\\n filelines = datastream.readlines()\\n datastream.close()\\n # Check that data exists\\n assert(filelines), 'The sounding file is empty.'\\n\\n # Initialize variables\\n PRESS = []\\n HGHT = []\\n TEMP = []\\n DRCT = []\\n SKNT = []\\n\\n if ext == '.ftr':\\n # READ THE .FTR INPUT FILE AND PASS ITS DATA TO THE\\n # process_sounding_data(...) METHOD.\\n\\n # Import data into variables\\n filelines = filelines[1:] # Remove header\\n for line in filelines:\\n lineEntries = line.split()\\n if len(lineEntries) == 12:\\n PRESS.append(float(lineEntries[2]))\\n HGHT.append(float(lineEntries[1]))\\n TEMP.append(float(lineEntries[3]))\\n DRCT.append(float(lineEntries[7]))\\n SKNT.append(float(lineEntries[6]))\\n\\n logger.debug('Data imported.')\\n progressHandler(0.5, 1)\\n\\n if self._process_sounding_data(PRESS, HGHT, TEMP, DRCT, SKNT):\\n progressHandler(1.0, 1)\\n self._weatherLoaded = True\\n logger.debug('Weather successfully loaded.')\\n else:\\n self._weatherLoaded = False\\n return\\n\\n\\n elif ext == '.sounding':\\n # READ THE .SOUNDING INPUT FILE AND PASS ITS DATA TO THE\\n # process_sounding_data(...) METHOD.\\n\\n # Check that data exists\\n if not filelines:\\n logger.error('The sounding file you specified is empty.')\\n return\\n\\n logger.debug('File reading completed.')\\n\\n # Detect first line of useful data\\n startLine = 0\\n for i in range(len(filelines)):\\n if filelines[i][0] == '-' and i < 25:\\n startLine = i + 1\\n\\n if startLine == 0:\\n logger.error('Sounding file format does not follow format standards!')\\n self._weatherLoaded = False\\n\\n # Import data into variables\\n for line in filelines[startLine:]:\\n try:\\n data = line.split()\\n if len(data) == 11:\\n PRESS.append(float(data[0]))\\n HGHT.append(float(data[1]))\\n TEMP.append(float(data[2]))\\n DRCT.append(float(data[6]))\\n SKNT.append(float(data[7]))\\n except ValueError:\\n # End of useful data\\n break\\n\\n logger.debug('Data imported.')\\n\\n if self._process_sounding_data(PRESS, HGHT, TEMP, DRCT, SKNT):\\n self._weatherLoaded = True\\n logger.debug('Weather successfully loaded.')\\n else:\\n self._weatherLoaded = False\\n return\",\n \"def loadascii(self, filename=None):\\n data = np.loadtxt(filename)\\n if len(data.shape) == 1:\\n self.flux = data\\n elif len(data.shape) == 2:\\n self.wavelength = data[:,0]\\n self.flux = data[:,1]\",\n \"def read_all_signals(self):\\n return [pio.sample(signal_idx)\\n for signal_idx in self._signals_idx]\",\n \"def load_info():\\n data = np.loadtxt(\\\"u_sol_meta.txt\\\", dtype=int)\\n return data\",\n \"def read_data(cls, input_file,quotechar = None):\\n if 'pkl' in str(input_file):\\n lines = load_pickle(input_file)\\n else:\\n lines = input_file\\n return lines\",\n \"def load_sotu_data():\\n sotu_files = glob.glob(\\\"sotu-data/*.txt\\\")\\n path_desc = re.compile(r\\\"sotu-data/([A-Za-z]+)_([0-9]{4})\\\\.txt\\\")\\n for filepath in sotu_files:\\n with open(filepath, \\\"r\\\") as f:\\n raw_text = f.read()\\n pres, year = path_desc.search(filepath).groups()\\n yield {\\\"president\\\": pres, \\\"year\\\": year, \\\"speech\\\": raw_text}\",\n \"def __init__(self, raw_data_file,):\\n self.raw_data_file = raw_data_file\\n self.clean_data = self.cleanData()\\n self.microtrip_data = []\",\n \"def load_data(self, data_file):\\n data = np.load(data_file)\\n states = data['states']\\n knack = data['knack']\\n knack_kurtosis = data['knack_kurtosis']\\n v = data['q_1_moment']\\n\\n extracted_data = {'states': states, 'v': normalize(v), 'knack': normalize(knack),\\n 'knack_kurtosis': normalize(knack_kurtosis)}\\n return extracted_data\",\n \"def read(self):\\n # open the .SPE file\\n with open(self._input_file_path, 'rb') as f:\\n lines = f.readlines()\\n # Create an empty dictionary for the metadata\\n metadata_dictionary = {}\\n\\n # Search through the file for the needed metadata\\n metadata_dictionary['date_acquired'] = re.search(b'date=\\\"(.*?)\\\"', lines[1])[1].decode('ANSI') \\n metadata_dictionary['width'] = int(re.search(b'width=\\\"(.*?)\\\"', lines[1])[1])\\n metadata_dictionary['height'] = int(re.search(b'height=\\\"(.*?)\\\"', lines[1])[1])\\n metadata_dictionary['size'] = metadata_dictionary['width']*metadata_dictionary['height']\\n metadata_dictionary['exposure_time'] = int(re.search(b'<ExposureTime type=\\\"Double\\\">(.*?)</ExposureTime>', lines[1])[1])\\n metadata_dictionary['excitation_wavelength'] = float(re.search(b'laserLine=\\\"(.*?)\\\"',lines[1])[1])\\n metadata_dictionary['center_wavelength'] = float(re.search(b'<CenterWavelength type=\\\"Double\\\">(.*?)</CenterWavelength>',lines[1])[1])\\n metadata_dictionary['orientation'] = re.search(b'orientation=\\\"(.*?)\\\"',lines[1])[1].decode('ANSI')\\n\\n # Get the wavelength and intensity\\n wavelength_string = re.search(b'<Wavelength xml:space=\\\"preserve\\\">(.*?)</Wavelength>',lines[1])[1].decode('utf-8')\\n wavelength = np.array(wavelength_string.split(','), dtype=np.float64)\\n\\n f.seek(4100)\\n intensity = np.fromfile(f,dtype=np.float32,count=metadata_dictionary['size'])\\n\\n raman_shift_wavenumbers = 1e7*(1/metadata_dictionary['excitation_wavelength'] - 1/wavelength)\\n\\n f.close()\\n \\n # create the sidpy dataset\\n data_set = Dataset.from_array(intensity, name='Raman Spectra')\\n\\n data_set.data_type = 'spectrum'\\n data_set.units = 'counts'\\n data_set.quantity = 'Intensity'\\n\\n # set dimensions\\n data_set.set_dimension(0, Dimension(raman_shift_wavenumbers, name='Raman Shift',\\n units = 'cm-1',\\n quantity='Raman shift',\\n dimension_type='spectral'))\\n data_set.set_dimension(1, Dimension(intensity, name='Intensity',\\n units = 'counts',\\n quantity='intensity',\\n dimension_type='spectral')) \\n\\n data_set.metadata = metadata_dictionary\\n\\n return data_set\",\n \"def t8_loadFile(self):\\n print \\\"spectrumFile\\\"\\n filename = tkFileDialog.askopenfilename()\\n filename = self.filenameparser(filename)\\n self.t8_filename = filename\",\n \"def read_process_song(path, window=1, overlap=0, debug=True):\\n\\n arr_features = []\\n\\n signal, sr = librosa.load(path)\\n signal = signal[:660000]\\n\\n # Debug process\\n if debug:\\n print(\\\"Reading file: {}\\\".format(path))\\n\\n # Split songs:\\n samples = split_songs(signal, window, overlap)\\n\\n # Append the result to the data structure\\n for s in samples:\\n features = get_features(s, sr)\\n arr_features.append(features)\\n return arr_features\",\n \"def load_data():\\n # Load in data\\n sample_frame = energy_connection.sample_series('energy_readings')\\n # TODO: Rooms/QL Extract\\n sample_frame = energy_connection.sample_series('external_readings', append_frame=sample_frame)\\n\\n # To object\\n sample = TimeSeriesSample(sample_frame, 'time')\\n\\n return sample\",\n \"def __loadFromFile(self):\\n fh = open(self.__fileName)\\n for line in fh:\\n if line.strip() == \\\" \\\":\\n continue # we have an empty line, just skip\\n sub = self.__createSubjectFromLine(line)\\n # invoke the store method from the base class\\n SubjectsRepo.store_subject(self, sub)\\n fh.close()\",\n \"def load_data_part(fname):\\n if \\\"_data\\\" not in fname:\\n return None\\n # Read data\\n data = pd.read_csv(fname)\\n # events file\\n events_fname = fname.replace('_data', '_events')\\n # read event file\\n labels = pd.read_csv(events_fname)\\n clean = data.drop(['id'], axis=1) # remove id\\n labels = labels.drop(['id'], axis=1) # remove id\\n return clean, labels\",\n \"def load_timestamps(timestamps_data_path):\\n timestamp_file = os.path.join(\\n timestamps_data_path, 'data.csv')\\n\\n timestamps = []\\n with codecs.open(timestamp_file, 'r', 'utf-8') as f:\\n for line in islice(f, 1, None):\\n t = float(\\\"{:.9f}\\\".format(float(line.split(',')[0]) / 1e9))\\n timestamps.append(t) \\n\\n # Subselect the chosen range of frames, if any\\n return timestamps\",\n \"def readFiles(self):\\n #return a list of traces\\n alltraces = []\\n for dfile in self._datafiles:\\n traces,headers = readgeonet(dfile)\\n alltraces += traces\\n return alltraces\",\n \"def read_converted_pickle(picklefile, channel=0):\\n\\n with bz2.BZ2File(picklefile, \\\"rb\\\") as f:\\n r = pickle.load(f)[channel]\\n\\n # r is now a list of dictionaries, one dict per trigger\\n # convert the data to numpy arrays\\n # and add a time key\\n for i in range(len(r)):\\n r[i]['data'] = np.array(r[i]['data'])\\n r[i]['time'] = r[i]['timeStamp'] + \\\\\\n np.arange(0., r[i]['data'].size / r[i]['samplingFreq'], 1. / r[i]['samplingFreq'])\\n\\n return r\",\n \"def readData(self):\\n f = open(self.filename)\\n self.time = []\\n self.data = []\\n for line in f:\\n if line.find('BAD FLAG') > 0:\\n self.badValue = float(line.split(':')[1].strip())\\n if line.find('LONGITUDE') > 0:\\n self.lon = line.split(':')[1].strip()\\n if line.find('LATITUDE') > 0:\\n self.lat = line.split(':')[1].strip()\\n if len(line) > 6 and line[2] == '-' and line[6] == '-':\\n parts = line.rsplit(None, 1)\\n # data line\\n timeStamp = datetime.datetime.strptime(parts[0], '%d-%b-%Y %H')\\n t = timeArray.datetimeToEpochTime(timeStamp)\\n self.time.append(t)\\n val = float(parts[1])\\n self.data.append(val)\\n\\n self.time = np.array(self.time)\\n self.data = np.array(self.data)\\n # remove bad values\\n if self.badValue:\\n goodIx = self.data != self.badValue\\n self.time = self.time[goodIx]\\n self.data = self.data[goodIx]\\n self.fileIsRead = True\",\n \"def LoadTroikaDataset():\\n data_dir = \\\"./datasets/troika/training_data\\\"\\n data_fls = sorted(glob.glob(data_dir + \\\"/DATA_*.mat\\\"))\\n ref_fls = sorted(glob.glob(data_dir + \\\"/REF_*.mat\\\"))\\n return data_fls, ref_fls\",\n \"def parse_lines_in_file(path):\\n signals = []\\n with open(path) as fp:\\n for line in fp:\\n # removes all text comments starting with # character\\n parts = line.partition('#')\\n line = parts[0]\\n\\n # removes starting and ending whitespace\\n line = line.strip()\\n if len(line) > 0:\\n signals.append(line)\\n return signals\",\n \"def _load(self):\\n\\n # number of non-data header details at top of data file\\n header = 1\\n\\n # open file\\n weatherData = []\\n with open(self.wfile) as myfile:\\n if (self.lines > 0):\\n weatherData = [next(myfile) for x in xrange(self.lines + header)]\\n else:\\n weatherData = myfile.readlines()\\n\\n # get data stream from first line\\n streamHeader = weatherData.pop(0).rstrip()\\n if (streamHeader == 'FULL'):\\n self.dataStream = 0\\n elif (streamHeader == 'ADVANCED'):\\n self.dataStream = 1\\n elif (streamHeader == 'BASIC'):\\n self.dataStream = 2\\n else:\\n print \\\"Error: unecognised data stream from file %s\\\" % (self.wfile)\\n return -1\\n\\n # read data\\n inputData = []\\n for line in weatherData:\\n entries = line.split()\\n inputData.append(entries)\\n\\n # copy all into np array\\n self.data = np.array(inputData)\\n\\n return 0\",\n \"def loadtrkfile(T_filename, threshold_short_streamlines=10.0):\\r\\n print(\\\"Loading %s\\\" % T_filename)\\r\\n T, hdr = trackvis.read(T_filename, as_generator=False)\\r\\n T = np.array([s[0] for s in T], dtype=np.object)\\r\\n \\r\\n\\r\\n \\r\\n return T\",\n \"def read_data(path, low=275000, high=300000):\\n data = read_pickle(path)\\n\\n Y1 = data['lowT_av'].squeeze()\\n Y2 = data['upT_av'].squeeze()\\n # LWC = data['lwc1V_av']\\n X = np.arange(Y1.shape[0]) / 100.\\n # X = data['time_av'].squeeze()\\n if low is not None and high is not None:\\n X = X[low:high]\\n Y1 = Y1[low:high]\\n Y2 = Y2[low:high]\\n\\n return X, Y1, Y2\",\n \"def load_timestamps(self):\\n print('Loading timestamps for sequence ' + self.sequence + '...')\\n\\n timestamp_file = os.path.join(self.sequence_path, 'times.txt')\\n\\n # Read and parse the timestamps\\n self.timestamps = []\\n with open(timestamp_file, 'r') as f:\\n for line in f.readlines():\\n t = dt.timedelta(seconds=float(line))\\n self.timestamps.append(t)\\n\\n # Subselect the chosen range of frames, if any\\n if self.frame_range:\\n self.timestamps = [self.timestamps[i] for i in self.frame_range]\\n\\n print('Found ' + str(len(self.timestamps)) + ' timestamps...')\\n\\n print('done.')\",\n \"def read_data(self, data_dir):\\n\\n # threshold for ZUPT ground truth\\n sm_velocity_max_threshold = 0.004 # m/s\\n\\n f = os.path.join(self.predata_dir, 'urban06.p')\\n if True and os.path.exists(f):\\n return\\n\\n print(\\\"Start read_data, be patient please\\\")\\n def set_path(seq):\\n path_imu = os.path.join(data_dir, seq, \\\"sensor_data\\\",\\n \\\"xsens_imu.csv\\\")\\n path_gt = os.path.join(data_dir, seq, \\\"global_pose.csv\\\")\\n return path_imu, path_gt\\n\\n time_factor = 1e9 # ns -> s\\n\\n def interpolate(x, t, t_int, angle=False):\\n \\\"\\\"\\\"\\n Interpolate ground truth with sensors\\n \\\"\\\"\\\"\\n x_int = np.zeros((t_int.shape[0], x.shape[1]))\\n for i in range(x.shape[1]):\\n if angle:\\n x[:, i] = np.unwrap(x[:, i])\\n x_int[:, i] = np.interp(t_int, t, x[:, i])\\n return x_int\\n\\n sequences = os.listdir(data_dir)\\n # read each sequence\\n for sequence in sequences:\\n print(\\\"\\\\nSequence name: \\\" + sequence)\\n path_imu, path_gt = set_path(sequence)\\n imu = np.genfromtxt(path_imu, delimiter=\\\",\\\")\\n\\n # Urban00-05 and campus00 have only quaternion and Euler data\\n if not imu.shape[1] > 10:\\n cprint(\\\"No IMU data for dataset \\\" + sequence, 'yellow')\\n continue\\n gt = np.genfromtxt(path_gt, delimiter=\\\",\\\")\\n\\n # time synchronization between IMU and ground truth\\n t0 = np.max([gt[0, 0], imu[0, 0]])\\n t_end = np.min([gt[-1, 0], imu[-1, 0]])\\n\\n # start index\\n idx0_imu = np.searchsorted(imu[:, 0], t0)\\n idx0_gt = np.searchsorted(gt[:, 0], t0)\\n\\n # end index\\n idx_end_imu = np.searchsorted(imu[:, 0], t_end, 'right')\\n idx_end_gt = np.searchsorted(gt[:, 0], t_end, 'right')\\n\\n # subsample\\n imu = imu[idx0_imu: idx_end_imu]\\n gt = gt[idx0_gt: idx_end_gt]\\n t = imu[:, 0]\\n\\n # take ground truth position\\n p_gt = gt[:, [4, 8, 12]]\\n p_gt = p_gt - p_gt[0]\\n\\n # take ground matrix pose\\n Rot_gt = torch.Tensor(gt.shape[0], 3, 3)\\n for j in range(3):\\n Rot_gt[:, j] = torch.Tensor(gt[:, 1 + 4 * j: 1 + 4 * j + 3])\\n q_gt = SO3.to_quaternion(Rot_gt)\\n # convert to angle orientation\\n rpys = SO3.to_rpy(Rot_gt)\\n t_gt = gt[:, 0]\\n # interpolate ground-truth\\n p_gt = interpolate(p_gt, t_gt, t)\\n rpys = interpolate(rpys.numpy(), t_gt, t, angle=True)\\n\\n # convert from numpy\\n ts = (t - t0)/time_factor\\n p_gt = torch.Tensor(p_gt)\\n rpys = torch.Tensor(rpys).float()\\n q_gt = SO3.to_quaternion(SO3.from_rpy(rpys[:, 0], rpys[:, 1], rpys[:, 2]))\\n imu = torch.Tensor(imu).float()\\n\\n # take IMU gyro and accelerometer and magnetometer\\n imu = imu[:, 8:17]\\n\\n dt = ts[1:] - ts[:-1]\\n # compute speed ground truth (apply smoothing)\\n v_gt = torch.zeros(p_gt.shape[0], 3)\\n for j in range(3):\\n p_gt_smooth = savgol_filter(p_gt[:, j], 11, 1)\\n v_j = (p_gt_smooth[1:] - p_gt_smooth[:-1]) / dt\\n v_j_smooth = savgol_filter(v_j, 11, 0)\\n v_gt[1:, j] = torch.Tensor(v_j_smooth)\\n\\n # ground truth specific motion measurement (binary)\\n zupts = v_gt.norm(dim=1, keepdim=True) < sm_velocity_max_threshold\\n zupts = zupts.float()\\n # set ground truth consistent with ZUPT\\n v_gt[zupts.squeeze() == 1] = 0\\n\\n # save for training\\n mondict = {\\n 'xs': zupts.float(),\\n 'us': imu.float(),\\n }\\n pdump(mondict, self.predata_dir, sequence + \\\".p\\\")\\n # save ground truth\\n mondict = {\\n 'ts': ts,\\n 'qs': q_gt.float(),\\n 'vs': v_gt.float(),\\n 'ps': p_gt.float(),\\n }\\n pdump(mondict, self.predata_dir, sequence + \\\"_gt.p\\\")\",\n \"def read(files, save):\\n\\t# NOTE all soundings are size obs long, they must be filled in with zeros for this data format...\\n\\t# create the HDF5 document\\n\\tdoc = h5(save)\\n\\tsize = 450 # this hopefully exceeds the size of the arrays # CPIN Files are much shorter...\\n\\tdoc.create(pres=size, temp=size, dewpt=size, rh=size, r=size, u=size, v=size, z=size, lat=1, lon=1, theta=size, thte=size,\\n\\t\\twspd=size, wdir=size, gamma=size, stab=size, N=size, rich=size, thtdef=size, cpin=size)\\n\\t# those last two do not have to be included...\\n\\t# Z=geopotenital height\\n\\n\\t# now read the files!\\n\\tfor f in sorted(files):\\n\\t\\tfname = f.split('/')[-1]\\n\\t\\t# if 'smth' not in fname and NCAR not in fname: continue\\n\\t\\tl.info('reading ' + fname)\\n\\t\\t# launch time comes from line 2 of the file, the last element\\n\\t\\tdf = open(f, 'r')\\n\\t\\ttxt = df.read(2000).split('\\\\n') # way more than we need\\n\\t\\tdf.close()\\n\\t\\tlatln = txt[0].split() # keys 1,2 will be what we want\\n\\t\\ttry:\\n\\t\\t\\ttm = s2t(txt[1].split()[-1] + 'UTC', '%Y%m%d%H%M%Z')\\n\\t\\texcept:\\n\\t\\t\\t# drat.\\n\\t\\t\\tprint txt.split('\\\\n')[1]\\n\\t\\t\\tcontinue\\n\\t\\ttry:\\n\\t\\t\\tif 'cpin' in fname:\\n\\t\\t\\t\\tz, p, t, td, rh, r, wb, tv, tht, thte, thtw, ws, wd, u, v, vflg, gamma, stab, N, rich, thtdef, cpin = np.loadtxt(f, skiprows=4, unpack=True)\\n\\t\\t\\t\\t# r is mixing ratio\\n\\t\\t\\telse:\\n\\t\\t\\t\\tz, p, t, td, rh, r, wb, tv, tht, thte, thtw, ws, wd, u, v, vflg, gamma, stab, N, rich = np.loadtxt(f, skiprows=4, unpack=True)\\n\\t\\t\\t\\t# r is mixing ratio\\n\\t\\texcept:\\n\\t\\t\\tl.warning('This file could not be read')\\n\\t\\t\\tcontinue\\n\\n\\t\\t# and append this data! I will trust the time seconds, instead of recomputing the time\\n\\t\\t# but, before that, we have to make them all the same size - size long\\n\\t\\tnl = np.zeros(size - t.shape[0]) - 999.00 # -999 array to fluff the end\\n\\t\\tp = np.concatenate((p, nl))\\n\\t\\tt = np.concatenate((t, nl))\\n\\t\\ttd = np.concatenate((td, nl))\\n\\t\\trh = np.concatenate((rh, nl))\\n\\t\\tr = np.concatenate((r, nl))\\n\\t\\ttv = np.concatenate((tv, nl))\\n\\t\\ttht = np.concatenate((tht, nl))\\n\\t\\tthte = np.concatenate((thte, nl))\\n\\t\\tws = np.concatenate((ws, nl))\\n\\t\\twd = np.concatenate((wd, nl))\\n\\t\\tgamma = np.concatenate((gamma, nl))\\n\\t\\tstab = np.concatenate((stab, nl))\\n\\t\\tN = np.concatenate((N, nl))\\n\\t\\trich = np.concatenate((rich, nl))\\n\\t\\tu = np.concatenate((u, nl))\\n\\t\\tv = np.concatenate((v, nl))\\n\\t\\tz = np.concatenate((z, nl))\\n\\t\\tif 'cpin' in fname:\\n\\t\\t\\tcpin = np.concatenate((cpin, nl))\\n\\t\\t\\tthtdef = np.concatenate((thtdef, nl))\\n\\t\\t\\tdoc.append(tm, persist=True, pres=p, temp=t, dewpt=td, rh=rh, r=r, u=u, v=v, z=z, lat=[latln[1]], lon=[latln[2]],\\n\\t\\t\\t\\ttheta=tht, thte=thte, wspd=ws, wdir=wd, gamma=gamma, stab=stab, N=N, rich=rich, cpin=cpin, thtdef=thtdef)\\n\\t\\telse:\\n\\t\\t\\tdoc.append(tm, persist=True, pres=p, temp=t, dewpt=td, rh=rh, r=r, u=u, v=v, z=z, lat=[latln[1]], lon=[latln[2]],\\n\\t\\t\\t\\ttheta=tht, thte=thte, wspd=ws, wdir=wd, gamma=gamma, stab=stab, N=N, rich=rich)\\n\\tdoc.close()\",\n \"def load(self, filename, build_hkl=True, load_instrument=False):\\n with open(filename) as f:\\n file_header = []\\n for i, line in enumerate(f):\\n if i == 0:\\n _length = int(re.findall(r\\\"(?='(.*?)')\\\", line)[-2])\\n [_m0, _prf] = [float(i) for i in re.findall(r\\\"(?='(.*?)')\\\", line)[-4].split()]\\n if 'Q(x)' in line:\\n args = line.split()\\n col_headers = [head for head in args]\\n break\\n\\n args = np.genfromtxt(filename, unpack=True, dtype=np.float64, skip_header=12)\\n\\n data = OrderedDict()\\n for head, col in zip(col_headers, args):\\n data[head] = col\\n\\n # add monitor column from header values\\n data['monitor'] = np.empty(args[0].shape)\\n data['monitor'].fill(_m0 * _prf)\\n\\n self._data = data\\n self._file_header = file_header\\n self.data_keys = {'detector': 'Counts', 'time': 'min', 'monitor': 'monitor'}\\n\\n if build_hkl:\\n self.Q_keys = {'h': 'Q(x)', 'k': 'Q(y)', 'l': 'Q(z)', 'e': 'E', 'temp': 'T-act'}\\n\\n if load_instrument:\\n instrument = Instrument()\\n self.instrument = instrument\",\n \"def load_data(data_file):\\n # Load data from files\\n data = list(codecs.open(data_file, \\\"r\\\", \\\"utf-8\\\").readlines())\\n x_text = [\\n [item for item in jieba.extract_tags(s, withWeight=False, topK=20, allowPOS=('n', 'v', 'nt', 'vn'))] for\\n s in data]\\n\\n return x_text\",\n \"def doImport(self, params):\\n #logging.info(params.filename)\\n raw_data = self.open_filename(params.filename)\\n #logging.info('file open ok')\\n data = self.split_to_blocks(raw_data)\\n #logging.info('splitting ok')\\n chromatograms = self.process_data_to_chromatograms(data)\\n #logging.info('extract ok')\\n \\n processed_data = []\\n \\n zero = params.field_results[\\\"zero\\\"]\\n MIC = params.field_results[\\\"MIC\\\"]\\n TIC = params.field_results[\\\"TIC\\\"]\\n round_MZ = params.field_results[\\\"round_MZ\\\"]\\n \\n for chrom in chromatograms:\\n \\n prefix = chrom['short_title']\\n if (\\\".\\\" in prefix) and round_MZ:\\n first,last = prefix.split('.')\\n prefix = first\\n \\n if (\\\"MIC\\\" in prefix) and (not MIC):\\n pass\\n elif (\\\"TIC\\\" in prefix) and (not TIC):\\n pass\\n else:\\n x = ImportDataset1D(name=prefix+'_time',data = chrom['time'])\\n if zero:\\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal_zero'])\\n else:\\n y = ImportDataset1D(name=prefix+'_signal',data = chrom['signal'])\\n processed_data.append(x)\\n processed_data.append(y)\\n \\n return processed_data\",\n \"def test_read_multiple_signals(self):\\n cwd = os.path.dirname(os.path.abspath(__file__))\\n test_dir = os.path.join(cwd, 'test_files/')\\n signals = read_signals(test_dir)\\n self.assertEqual(len(signals), 3)\\n self.assertTrue(\\n any(signal for signal in signals if signal.name == \\\"test1\\\"))\\n self.assertTrue(\\n any(signal for signal in signals if signal.name == \\\"test2\\\"))\\n self.assertTrue(\\n any(signal for signal in signals if signal.name == \\\"test3\\\"))\",\n \"def load_cleaned_data(self):\\n try:\\n self.train = pd.read_pickle('../input/train_clean.pkl')\\n self.test = pd.read_pickle('../input/test_clean.pkl')\\n except FileNotFoundError:\\n self.load_raw_data()\",\n \"def __parse_file(self):\\n\\n if PY2:\\n text = lambda v: v.decode('utf-8')\\n else:\\n text = lambda v: v\\n with open(self._file, 'r') as csvfile:\\n reader = csv.reader(csvfile, delimiter=';')\\n for row in reader:\\n try:\\n siruta = int(row[0])\\n except ValueError:\\n self.__notify_error(\\\"Line %s has an invalid SIRUTA code\\\" % str(row))\\n continue\\n if not self.siruta_is_valid(siruta):\\n self.__notify_error(\\\"SIRUTA code %d is not valid\\\" % siruta)\\n if len(row) != 15:\\n self.__notify_error(\\\"Line %s does not have 15 elements\\\" % str(row))\\n continue\\n if row[7] == \\\"1\\\":\\n urban = True\\n else:\\n urban = False\\n self._data[siruta] = {\\n 'siruta': siruta,\\n 'name': text(row[1]).translate(self._dia_trans),\\n 'postcode': int(row[2]),\\n 'county': int(row[3]),\\n 'sirutasup': int(row[4]),\\n 'type': int(row[5]),\\n 'level': text(row[6]),\\n 'urban': urban,\\n 'region': int(row[8]),\\n }\",\n \"def loadtrkfile(T_filename, threshold_short_streamlines=10.0):\\r\\n print(\\\"Loading %s\\\" % T_filename)\\r\\n T, hdr = trackvis.read(T_filename, as_generator=False)\\r\\n T = np.array([s[0] for s in T], dtype=np.object)\\r\\n \\r\\n\\r\\n \\r\\n return T, hdr\",\n \"def __read_data__(self):\\n with open(self.file, 'r') as data:\\n sentence = []\\n tags = []\\n for line in data:\\n terms = line.rstrip().split(WHITESPACE)\\n for term in terms:\\n word_tag = tuple(term.split(TAGCHAR))\\n word = word_tag[0]\\n tag = word_tag[1]\\n self.word_tag_dict[word_tag] += 1\\n self.tag_dict[tag] += 1\\n self.__add_to_word_dict__(word, tag)\\n if self.isNumberWord(word):\\n self.numbers += 1\\n if word[0].isupper() and len(sentence) > 0:\\n self.cap_no_start += 1\\n sentence.append(word)\\n tags.append(tag)\\n if tag == ENDOFSENTENCE:\\n self.sentences.append(tuple(sentence))\\n self.tags.append(tuple(tags))\\n sentence = []\\n tags = []\",\n \"def test_read_multiple_specified_signals(self):\\n cwd = os.path.dirname(os.path.abspath(__file__))\\n test_dir = os.path.join(cwd, 'test_files/')\\n signals = read_signals(test_dir, ['test2', 'test3'])\\n self.assertEquals(len(signals), 2)\",\n \"def load_scitail(file, label_dict):\\n rows = []\\n cnt = 0\\n with open(file, encoding=\\\"utf8\\\") as f:\\n for line in f:\\n blocks = line.strip().split('\\\\t')\\n assert len(blocks) > 2\\n if blocks[0] == '-': continue\\n sample = {'uid': str(cnt), 'premise': blocks[0], 'hypothesis': blocks[1], 'label': label_dict[blocks[2]]}\\n rows.append(sample)\\n cnt += 1\\n return rows\",\n \"def parse(filepath):\\n data = []\\n\\n with open(filepath, 'r') as file:\\n line = next(file)\\n while line:\\n str_line = line.strip()\\n if(str_line.startswith(\\\"Cell\\\")):\\n dict_entry = {\\n 'address': \\\"\\\",\\n 'channel': \\\"\\\",\\n 'frequency': \\\"\\\",\\n 'quality': \\\"\\\",\\n 'sLevel': \\\"\\\",\\n 'essid': \\\"\\\"\\n }\\n dict_entry[\\\"address\\\"] = line.split(\\\": \\\")[1].strip()\\n if(str_line.startswith(\\\"Channel\\\")):\\n dict_entry[\\\"channel\\\"] = line.split(\\\":\\\")[1].strip()\\n \\n if(str_line.startswith(\\\"Frequency\\\")):\\n reg_match = _RegExLib(str_line)\\n dict_entry[\\\"frequency\\\"] = reg_match.frequency.group(1)\\n\\n \\n\\n if(str_line.startswith(\\\"Extra: Last beacon\\\")):\\n data.append(dict_entry)\\n \\n \\n\\n line = next(file, None)\\n\\n return data\",\n \"def test_load_gtis(self):\\n fits_file = os.path.join(self.datadir, 'monol_testA.evt')\\n hen.io.load_gtis(fits_file)\",\n \"def _read_arasim_antenna_pickle(filename):\\n # Quick fix for filenames with one of the approved extensions already\\n # (just strip it)\\n if filename.endswith(\\\".txt\\\") or filename.endswith(\\\".pkl\\\"):\\n filename = filename[:-4]\\n\\n # If there is no pickle file, read the response data using the\\n # _read_arasim_antenna_data function, and then make a pickle file\\n if not os.path.isfile(filename+\\\".pkl\\\"):\\n logger.warning(\\\"Antenna model file %s.pkl not found. \\\"+\\n \\\"Generating a new file now\\\", filename)\\n response_data = _read_arasim_antenna_data(filename+\\\".txt\\\")\\n with open(filename+\\\".pkl\\\", 'wb') as f:\\n pickle.dump(response_data, f)\\n return response_data\\n\\n # Otherwise, read from the pickle file\\n else:\\n with open(filename+\\\".pkl\\\", 'rb') as f:\\n return pickle.load(f)\",\n \"def dataload():\\n\\t\\n\\tglobal A, B, fnA, fnB, lPcnA, lPcnB\\n\\t\\n\\tdwd = os.getcwd() # Data WD\\n\\t\\t\\n\\t# First sample A is loaded. This is the \\\"calibrating\\\" sample.\\n\\t# In this case it is the OGLE III LMC small amplitude RGs.\\n\\t\\n\\tfnA = '/LMC-CalSample-cleaned_2.fits'\\n\\tA = Table.read(dwd+fnA)\\n\\n\\t# Then sample B is loaded. For comparison/testing purposes, this is\\n\\t# again the OGLE III LMC SARGs.\\n\\t\\n\\tfnB = '/LMC-CalSample-cleaned_2.fits'\\n\\tB = Table.read(dwd+fnB)\\n\\t\\n\\t\\\"\\\"\\\" Fix tables so only the stars with all three good periods are \\n\\tconsidered. \\\"\\\"\\\"\\n\\t\\n\\tlPcnA = get_logPcn(A)\\n\\tlPcnB = get_logPcn(B)\\n\\t\\n\\tfor cn in lPcnA:\\n\\t\\tA = A[A[cn]>0]\\n\\tfor cn in lPcnB:\\n\\t\\tB = B[B[cn]>0]\",\n \"def loadtcdat(filename= None):\\n\\n import numpy as np\\n from StringIO import StringIO\\n import Tkinter\\n from tkFileDialog import askopenfilename\\n from matplotlib.pyplot import figure,subplot,plot,xlabel,ylabel,title,legend\\n\\n if filename is not None:\\n print \\\"Opening %s\\\\n\\\" %(filename)\\n else:\\n root = Tkinter.Tk()\\n root.withdraw()\\n filename = askopenfilename(parent=root, title='Open File',\\n filetypes=[('csv files', '*.csv'),\\n ('txt files', '*.txt')])\\n root.destroy()\\n root.mainloop()\\n\\n if filename is not None:\\n f=open(filename)\\n names = f.readline()\\n names = names.strip('\\\\r\\\\n')\\n names = names.split(\\\",\\\")\\n f.close()\\n\\n data = np.genfromtxt(filename, delimiter=',',\\n unpack=True, skip_header=2)\\n time = data[0]\\n\\n figure()\\n subplot(211)\\n plot(time, data[1], label='Feed bin')\\n plot(time, data[2], label='Part bin')\\n ylabel(r'$ T_{bin} \\\\left(K\\\\right) $')\\n legend(loc='best')\\n\\n subplot(212)\\n plot(time,data[4],label='Feed bin heater')\\n plot(time,data[5],label='Part bin heater')\\n xlabel(r'$ Time \\\\left(s\\\\right) $')\\n ylabel(r'$ P_{heater} \\\\left( \\\\frac{W}{m^2} \\\\right) $')\\n legend(loc='best')\\n\\n return (data, time, names)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.626287","0.62021583","0.6054611","0.5924737","0.5851997","0.5830161","0.5783297","0.573766","0.5731504","0.57031226","0.5665131","0.56484056","0.5623416","0.56071955","0.5598461","0.5585858","0.55778784","0.55460054","0.5543505","0.553586","0.5512837","0.54953873","0.5491607","0.5483067","0.5481157","0.54800034","0.5467627","0.54562396","0.544912","0.54367805","0.5420866","0.5408083","0.54038054","0.5388073","0.5386272","0.5384042","0.5382555","0.534647","0.53404814","0.5335164","0.5306748","0.52925736","0.52816856","0.5279813","0.52724254","0.5264676","0.5263342","0.52604437","0.5257681","0.525365","0.5253453","0.52401084","0.5235714","0.52248013","0.52227426","0.5214939","0.5207433","0.5201092","0.5191952","0.5191021","0.51905996","0.51894","0.5188957","0.5188824","0.51878667","0.51855683","0.51812154","0.517986","0.51696455","0.5165308","0.516338","0.5158069","0.5158014","0.515353","0.5145258","0.5144543","0.51422286","0.5140008","0.5138171","0.5135597","0.51313376","0.5127108","0.51266193","0.51231617","0.5119375","0.51112425","0.5108896","0.5108335","0.5107618","0.51074445","0.5105021","0.5104912","0.5100237","0.50913256","0.5088016","0.508304","0.5082037","0.5079452","0.50786173","0.5075724"],"string":"[\n \"0.626287\",\n \"0.62021583\",\n \"0.6054611\",\n \"0.5924737\",\n \"0.5851997\",\n \"0.5830161\",\n \"0.5783297\",\n \"0.573766\",\n \"0.5731504\",\n \"0.57031226\",\n \"0.5665131\",\n \"0.56484056\",\n \"0.5623416\",\n \"0.56071955\",\n \"0.5598461\",\n \"0.5585858\",\n \"0.55778784\",\n \"0.55460054\",\n \"0.5543505\",\n \"0.553586\",\n \"0.5512837\",\n \"0.54953873\",\n \"0.5491607\",\n \"0.5483067\",\n \"0.5481157\",\n \"0.54800034\",\n \"0.5467627\",\n \"0.54562396\",\n \"0.544912\",\n \"0.54367805\",\n \"0.5420866\",\n \"0.5408083\",\n \"0.54038054\",\n \"0.5388073\",\n \"0.5386272\",\n \"0.5384042\",\n \"0.5382555\",\n \"0.534647\",\n \"0.53404814\",\n \"0.5335164\",\n \"0.5306748\",\n \"0.52925736\",\n \"0.52816856\",\n \"0.5279813\",\n \"0.52724254\",\n \"0.5264676\",\n \"0.5263342\",\n \"0.52604437\",\n \"0.5257681\",\n \"0.525365\",\n \"0.5253453\",\n \"0.52401084\",\n \"0.5235714\",\n \"0.52248013\",\n \"0.52227426\",\n \"0.5214939\",\n \"0.5207433\",\n \"0.5201092\",\n \"0.5191952\",\n \"0.5191021\",\n \"0.51905996\",\n \"0.51894\",\n \"0.5188957\",\n \"0.5188824\",\n \"0.51878667\",\n \"0.51855683\",\n \"0.51812154\",\n \"0.517986\",\n \"0.51696455\",\n \"0.5165308\",\n \"0.516338\",\n \"0.5158069\",\n \"0.5158014\",\n \"0.515353\",\n \"0.5145258\",\n \"0.5144543\",\n \"0.51422286\",\n \"0.5140008\",\n \"0.5138171\",\n \"0.5135597\",\n \"0.51313376\",\n \"0.5127108\",\n \"0.51266193\",\n \"0.51231617\",\n \"0.5119375\",\n \"0.51112425\",\n \"0.5108896\",\n \"0.5108335\",\n \"0.5107618\",\n \"0.51074445\",\n \"0.5105021\",\n \"0.5104912\",\n \"0.5100237\",\n \"0.50913256\",\n \"0.5088016\",\n \"0.508304\",\n \"0.5082037\",\n \"0.5079452\",\n \"0.50786173\",\n \"0.5075724\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6063819"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":23199,"cells":{"query":{"kind":"string","value":"Loads and extracts reference from a troika reference file."},"document":{"kind":"string","value":"def LoadTroikaRefFile(ref_fl):\n refdata = sp.io.loadmat(ref_fl)['BPM0']\n return refdata[2:]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_reference(self, path_to_reference):\n with open(path_to_reference,'r') as f:\n qids_to_relevant_docids = self.load_reference_from_stream(f)\n return qids_to_relevant_docids","def test_load_ref():\n\n itraj = os.path.join(path, \"alanine_dipeptide.nc\")\n iref = os.path.join(path, \"alanine_dipeptide.ncrst\")\n itop = os.path.join(path, \"alanine_dipeptide.parm7\")\n\n with pytest.raises(ValueError):\n ref = tools.load_ref(itraj, itop)\n\n ref = tools.load_ref(iref, itop)\n\n assert ref.n_frames == 1\n assert ref.n_atoms == 1912","def _load_ref(self, ref_uri, session):\n if self.verbose:\n print(\"Resolving $ref URI {}\".format(ref_uri), file=sys.stderr)\n parsed_ref_uri = self._parse_ref_uri(ref_uri)\n ref_file = parsed_ref_uri.netloc + parsed_ref_uri.path\n if not ref_file: # must be relative to current doc\n pass # is already in cache\n elif ref_file not in self.cache:\n self.cache[ref_uri] = self._load_for_cache(parsed_ref_uri, session)\n ref_json = self.cache[ref_uri]\n expr = jsonpath_rw.parse(\"$\" + \".\".join(parsed_ref_uri.fragment.split(\"/\")))\n for match in expr.find(ref_json):\n return match.value # return first match only\n # If we reach here, resolution failed\n raise RefResolutionException('Could not resolve reference URI \"{}\"'.format(ref_uri))","def extract_references_from_txt(filename):\n file = open(filename)\n references_section = \"\"\n references_section_found = False\n for line in file:\n if \"REFERENCE\" in line:\n references_section_found = True\n if references_section_found:\n references_section+=line + \" \"\n references_section = references_section.replace('\\n','')\n refs = extract_references(references_section)\n return refs","def _load_ref(self, doc_uri, doc, ref_uri):\n if self.verbose:\n print('Resolving $ref URI {}'.format(ref_uri), file=sys.stderr)\n parsed_ref_uri = self._parse_ref_uri(ref_uri)\n ref_file = parsed_ref_uri.netloc + parsed_ref_uri.path\n if not ref_file: # must be relative to current doc\n pass # is already in cache\n elif ref_file not in self.cache:\n self.cache[ref_uri] = self._load_for_cache(\n doc_uri, doc, parsed_ref_uri)\n ref_json = self.cache[ref_uri]\n expr = jsonpath_rw.parse(\n '$' + '.'.join(parsed_ref_uri.fragment.split('/')))\n for match in expr.find(ref_json):\n return match.value # return first match only\n # If we reach here, resolution failed\n raise RefResolutionException(\n 'Could not resolve reference URI \"{}\"'.format(ref_uri))","def load_references(self, collections, item):","def refl_load(file_descriptors):\n modules = [{\"module\": \"ncnr.refl.load\", \"version\": \"0.1\", \"config\": {}}]\n template = Template(\"test\", \"test template\", modules, [], \"ncnr.magik\", version='0.0')\n retval = process_template(template, {0: {\"files\": file_descriptors}}, target=(0, \"output\"))\n return retval.todict()","def parseReference(self):\n libxml2mod.xmlParseReference(self._o)","def resolve_reference(self, key, filetype=None):\n return self.__resolve_reference(\n key,\n self.get_metainfo().get(key), # TODO: use Java method with metaKey instead of getting metainfo here\n checked_filetype(filetype)\n )","def load_conanfile(self, conanfile_path, ref, graph_lock=None, remotes=None,\n update=None, check_update=None):\n try:\n conanfile, _ = self.load_basic_module(conanfile_path, graph_lock, str(ref), remotes,\n update=update, check_update=check_update)\n except Exception as e:\n raise ConanException(\"%s: Cannot load recipe.\\n%s\" % (str(ref), str(e)))\n\n conanfile.name = ref.name\n conanfile.version = str(ref.version)\n conanfile.user = ref.user\n conanfile.channel = ref.channel\n return conanfile","def ref(request):\n r = referencepytest.ref(request)\n this_dir = os.path.abspath(os.path.dirname(__file__))\n r.set_data_location(os.path.join(this_dir, '..', 'reference'))\n return r","def read_refcopy(f):\n\n d_refcopy = {}\n for n, line in enumerate(open(f)):\n if line.startswith('#'):\n continue\n\n line = line.rstrip()\n if line == '':\n continue\n\n _lis = line.split('\\t')\n taxa, num, = _lis[:2]\n skip = False\n for word in EXCLUDE:\n if word in taxa:\n skip = True\n break\n\n if skip:\n continue \n\n # the parsing of taxa works for both mothur output and this\n taxa = taxa.rstrip(';') # for mothur classfy.seqs output\n lis = taxa.split(';')\n lis2 = []\n for item in lis:\n item = item.strip() # for copyrigher copy table ' ;' separater\n if item.endswith(')'):\n item = item.rsplit('(', 1)[0].strip()\n\n # remove taxon level prefix, e.g. 'p__Firmicutes'\n if '__' in item:\n item = item.split('__', 1)[1]\n\n #item = item.strip('\"')\n\n # green gene taxonomy has sapce\n item = item.replace(' ', '_')\n\n item = item.lower()\n if item in ['', 'unknown', 'other', 'unassigned']:\n item = 'Unclassifed'\n\n item = item.capitalize()\n lis2.append(item)\n\n length = len(lis2)\n assert length <= LEVELS, '> {} levels found ({})'.format(\n LEVELS, length)\n if length != LEVELS:\n lis2 = lis2 + ['Unclassified']*(LEVELS - length)\n\n tu = tuple(lis2)\n d_refcopy[tu] = float(num)\n\n return d_refcopy","def load_reference_from_stream(self, f):\n qids_to_relevant_docids = {}\n for l in f:\n vals = l.strip().split('\\t')\n if len(vals) != 4:\n vals = l.strip().split(' ')\n if len(vals) != 4:\n pdb.set_trace()\n raise IOError('\\\"%s\\\" is not valid format' % l)\n\n qid = vals[0]\n if qid in qids_to_relevant_docids:\n pass\n else:\n qids_to_relevant_docids[qid] = []\n _rel = int(vals[3])\n if _rel > 0:\n qids_to_relevant_docids[qid].append(vals[2])\n\n return qids_to_relevant_docids","def referenced_by(self, refobj):\n try:\n ref = cmds.referenceQuery(refobj, referenceNode=True)\n return ref\n except RuntimeError as e:\n if str(e).endswith(\"' is not from a referenced file.\\n\"):\n return None\n else:\n raise e","def load(self, reference_file=None):\n lake = self.services.lake\n\n if reference_file is None:\n reference_file = self.get_local_path(self.filename_reference)\n\n logging.info(\n f\"ModelContainer {self.name} loading container from {reference_file}\"\n )\n with open(reference_file) as f:\n reference = json.load(f)\n\n # Load the distributions\n dist_ref = reference[\"distributions\"]\n dist_path = self.get_local_path(self.filename_distributions)\n lake.download(dist_ref[\"path\"], dist_path)\n self.load_distributions(dist_path)\n\n # Load the model\n model_ref = reference[\"model\"]\n model_path = self.get_local_path(self.filename_model)\n lake.download(model_ref[\"path\"], model_path)\n self.load_model()","def read_refgene_file(self, file_path):\n with open(file_path) as fi:\n for line in fi:\n content = line.strip().split()\n refgene = RefGene()\n refgene.bin = int(content[0])\n refgene.name, refgene.chrom, refgene.strand = content[1], content[2].lower(), content[3]\n refgene.tx_start, refgene.tx_end = int(content[4]), int(content[5])\n refgene.cds_start, refgene.cds_end = int(content[6]), int(content[7])\n refgene.exon_count = int(content[8])\n refgene.exon_starts = [int(e) for e in content[9][:-1].split(',')]\n refgene.exon_ends = [int(e) for e in content[10][:-1].split(',')]\n refgene.core, refgene.name2 = int(content[11]), content[12]\n refgene.cds_start_stat, refgene.cds_end_stat = content[13], content[14]\n # refgene.exon_frames = [int(e) for e in content[15][:-1].split(',')]\n self.ref_genes.append(refgene)","def read_reference(conformation_fname):\r\n\r\n #Create empty set\r\n reference_atoms = []\r\n\r\n #Try/catch if file cannot be found. Open file in read mode\r\n #For eveyr line in the text file, strip all white spaces from front and back\r\n #If not empty line, split line on commas and put integers in set. These correspond to atom numbers of the key atoms\r\n #Return this list\r\n\r\n try:\r\n with open(conformation_fname, \"r\") as fin :\r\n num = 1\r\n for line in fin:\r\n if num < 10:\r\n num = num + 1\r\n continue\r\n content = line.strip()\r\n if content == '':\r\n continue\r\n else:\r\n reference_atoms.append(content.split())\r\n #reference_atom_num.update([int(i) for i in content.split(',')])\r\n return reference_atoms\r\n #Catch OS error\r\n except OSError:\r\n print('OS error')\r\n sys.exit()\r\n #Catch value error (not appropriate values to be converted to int)\r\n except ValueError:\r\n print('Could not convert data to integer')\r\n sys.exit()","def _get_references_data(wit_path):\n\n with open(os.path.join(wit_path, '.wit', 'references.txt'), 'r') as data:\n info = {'None': 'None'}\n info.update({'HEAD': data.readline().split('=')[-1].strip('\\n')})\n info.update({'master': data.readline().split('=')[-1].strip('\\n')})\n for row in data.readlines():\n name, commit_id = row.split('=')\n info.update({name.strip('\\n'): commit_id.strip('\\n')})\n\n return info","def load_from_folder(folder):\n refs = []\n for input_file in os.listdir(folder):\n if input_file.endswith(\".ref\"):\n refs.append(Reference(folder, input_file))\n return refs","def trieFromFile(fname_ref):\n global gTrie\n\n with open(fname_ref) as f:\n motifs = f.readlines() \n # if first line already contains a motif, change 1 to 0 in line below\n for m in motifs[1:]:\n m = m.split(',')[0]\n gTrie[m] = 1","def load_ref_case(fname, name):\r\n with open(fname, 'rb') as f:\r\n\r\n a = np.load(f)\r\n\r\n data = a[name]\r\n \r\n return data","def parse_ref_file(file, start_pos=2, end_pos=7):\n data = []\n ref_dict = {}\n try:\n with open(file) as f:\n content = f.read()\n data = [word for lines in content.split(';')[start_pos: end_pos] for word in lines.splitlines(True) if '=' in word]\n for item in data:\n k = item.split('=')[0].strip().strip(\"'\")\n v = item.split('=')[1].strip().strip(\"'\") \n if k not in ref_dict:\n ref_dict[k] = v\n except Exception as e:\n logger.info('Failed to parse SAS dictionary...')\n return {}\n return ref_dict","def get_reference_properties(filename):\n try: # Hopefully it's a nice new standard filename, easy\n return decompose_newstyle_name(filename)\n except AssertionError: # cryptic legacy paths & names, i.e. reality\n pass\n # If not, dig inside the FITS file, slow\n return ref_properties_from_header(filename)","def extract_ref(line, refType):\n target = '\\\\' + refType + '{'\n\n start = line.find(target)\n for i in range(start, len(line)):\n if line[i] == '}':\n ref = line[start + len(target) : i]\n break\n return ref","def test_references(self):\n with sphinx_build('pyexample'):\n with open('_build/text/docfx_yaml/example.example.yml') as yml_file:\n data = yaml.safe_load(yml_file)\n # Test that references are properly put at the top-level\n self.assertTrue(\n 'references' in data\n )\n # Check reference parent\n self.assertEqual(\n data['references'][0]['parent'],\n 'example.example'\n\n )","def fetch_reads_from_reference(self, ref):\n try:\n print(\"Fetching reads from object {}\".format(ref))\n reads_client = ReadsUtils(self.callback_url)\n reads_dl = reads_client.download_reads({\n \"read_libraries\": [ref],\n \"interleaved\": \"false\"\n })\n pprint(reads_dl)\n reads_files = reads_dl['files'][ref]['files']\n ret_reads = {\n \"object_ref\": ref,\n \"style\": reads_files[\"type\"],\n \"file_fwd\": reads_files[\"fwd\"]\n }\n if reads_files.get(\"rev\", None) is not None:\n ret_reads[\"file_rev\"] = reads_files[\"rev\"]\n return ret_reads\n except:\n print(\"Unable to fetch a file from expected reads object {}\".format(ref))\n raise","def loadReferenceContigs(referencePath, alignmentSet, windows=None):\n # FIXME we should get rid of this entirely, but I think it requires\n # fixing the inconsistency in how contigs are referenced here versus in\n # pbcore.io\n\n # Read contigs from FASTA file (or XML dataset)\n refReader = ReferenceSet(referencePath)\n contigs = []\n if windows is not None:\n refNames = set([rw.refName for rw in windows])\n for contig in refReader:\n if contig.id in refNames:\n contigs.append(contig)\n else:\n contigs.extend([x for x in refReader])\n contigDict = dict([(x.id, x) for x in contigs])\n\n # initially each contig has an id of None -- this will be overwritten with the id from the cmp.h5, if there are any\n # reads mapped to it.\n for x in contigs:\n x.cmph5ID = None\n\n # Mark each contig with it's ID from the cmp.h5 - match them up using MD5s\n for x in alignmentSet.referenceInfoTable:\n if x.FullName in contigDict:\n contigDict[x.FullName].cmph5ID = x.ID\n\n return contigs","def reloadReference(*args):\n \n sel = cmds.textScrollList(widgets[\"shotAssListTSL\"], q=True, si=True)\n if sel:\n for s in sel:\n path = pi.referenceDictionary[s]\n cmds.file(path, loadReference=True)\n\n populateSceneRefs()","def get_reference_file(dataset, reference_file_type, observatory=None, asn_exptypes=None):\n if isinstance(dataset, str):\n from jwst import datamodels\n with datamodels.open(dataset, asn_exptypes=asn_exptypes) as model:\n return get_multiple_reference_paths(\n model, [reference_file_type], observatory)[reference_file_type]\n else:\n return get_multiple_reference_paths(\n dataset, [reference_file_type], observatory)[reference_file_type]","def read_gitref():\n\n gitref = module.directory.joinpath('.gitref')\n if gitref.is_file():\n with gitref.open('r') as fp:\n return fp.read().strip()\n return '<unknown_gitref>'","def retrieve(dbxrefs, basics=True, hierarchy=True, wikipedia=True, literature=True, cross_references=True, overlaps=True):\n resolved = dbxref.resolver.resolve(dbxrefs, check_existence=False)\n documents = []\n for entry in resolved:\n # Construct URL for retrieve\n json_url = entry['locations']['json'][0]\n logger.debug('URL: %s', json_url)\n r = requests.get(json_url)\n logger.debug('Content: %s', r.text)\n ipro = json.loads(r.text)\n\n # Parse retrieved json file by selected Options\n output = {\"id\": entry[\"dbxref\"]}\n if basics:\n try:\n output.update(accession=ipro[\"metadata\"][\"accession\"], entry_type=ipro[\"metadata\"][\"type\"],\n description=ipro[\"metadata\"][\"description\"], counters=ipro[\"metadata\"][\"counters\"],\n entry_id=ipro[\"metadata\"][\"entry_id\"], name=ipro[\"metadata\"][\"name\"],\n source_database=ipro[\"metadata\"][\"source_database\"])\n except KeyError:\n logger.warning(\"One or more basic information were not available for the given entry. Please check your output.\")\n if hierarchy:\n try:\n output.update(hierarchy=ipro[\"metadata\"][\"hierarchy\"])\n except KeyError:\n logger.warning(\"Hierarchy information was not available for the given entry.\")\n if wikipedia:\n try:\n output.update(wikipedia=ipro[\"metadata\"][\"wikipedia\"])\n except KeyError:\n logger.warning(\"Wikipedia articles were not available for the given entry.\")\n if literature:\n try:\n output.update(literature=ipro[\"metadata\"][\"literature\"])\n except KeyError:\n logger.warning(\"Literature was not available for the given entry.\")\n if cross_references:\n try:\n output.update(cross_references=ipro[\"metadata\"][\"cross_references\"])\n except KeyError:\n logger.warning(\"Cross_references were not available for the given entry.\")\n if overlaps:\n try:\n output.update(overlaps=ipro[\"metadata\"][\"overlaps_with\"])\n except KeyError:\n logger.warning(\"Overlap information was not available for the given entry.\")\n documents.append(output)\n return documents","def prepare_reference(reference_fp):\n # create .fai if doesn't yet exist\n if not os.path.isfile(re.sub(r'.[^.]*$', '.fai', reference_fp)):\n logging.info('preparing reference .fai')\n tool_args = ('samtools', 'faidx', reference_fp)\n logging.info(f'executing the following command: {\" \".join(tool_args)}')\n subprocess.check_output(tool_args)\n\n # create .dict file if doesn't yet exist\n if not os.path.isfile(re.sub(r'.[^.]*$', '.dict', reference_fp)):\n logging.info('preparing reference .dict')\n tool_args = ('picard', 'CreateSequenceDictionary',\n f'R={reference_fp}',\n 'O=' + re.sub(r'.[^.]*$', '.dict', reference_fp))\n logging.info(f'executing the following command: {\" \".join(tool_args)}')\n subprocess.check_output(tool_args)","def get_reference(self, compare_path):\n if compare_path:\n with open(compare_path, 'r') as f:\n reference = json.load(f)\n return reference[\"boxes\"]\n return None","def load(self, file_id):\n pass","def read_reference():\n global reference\n reference = cv2.imread(REFERENCE)\n print(reference)\n print(reference.shape)","def load_lookup_dicto():\n with open(LOOKUP_PATH, 'rb') as f:\n lookup_dicto = pickle.load(f)\n return lookup_dicto","def parse_file(path):\n with open(path, 'rb') as f:\n content = f.read()\n\n # Extract references from the parsed content\n references = extract_references(content)\n\n # Remove references from the parsed content\n for ref_id in references:\n content = content.replace(references[ref_id], ' ' * len(references[ref_id]))\n return content","def xref(filename, from_file=None):\n\n\t# First, if the file itself exists, use that file.\n\tif os.path.exists(filename):\n\t\treturn filename\n\n\tdirectory, basename = os.path.split(filename)\n\n\tx1 = filename+\".xref.txt\"\n\n\n\t# Then look for a file-specific xref\n\tif os.path.exists(x1):\n\n\t\t# Extract the content of the xref file\n\t\twith open(x1, 'r') as f:\n\t\t\talt_file = f.read()\n\n\t\t# Direct return of ref file if it is an absolute path and it exists\n\t\tif os.path.isabs(alt_file):\n\t\t\tif os.path.exists(alt_file):\n\t\t\t\treturn alt_file\n\t\t\telse:\n\t\t\t\traise FileNotFoundError(alt_file)\n\n\t\telse:\n\t\t\t# it is a relative path\n\t\t\talt_path = os.path.normpath(os.path.join(directory, alt_file))\n\t\t\tif from_file:\n\t\t\t\treturn xref(alt_path, from_file=x1+\"\\n from: \"+from_file)\n\t\t\treturn xref(alt_path, from_file=x1)\n\n\tx2d = os.path.join(directory, '_.xref.txt')\n\n\t# Then look for a dir-based xref\n\tif os.path.exists(x2d):\n\n\t\t# Extract the content of the xref file\n\t\twith open(x2d, 'r') as f:\n\t\t\talt_dir = f.read()\n\n\t\tx2 = os.path.normpath(os.path.join(directory, alt_dir, basename))\n\t\tif from_file:\n\t\t\treturn xref(x2, from_file=x2d + \"\\n from: \" + from_file)\n\t\treturn xref(x2, from_file=x2d)\n\n\tif from_file:\n\t\traise FileNotFoundError(filename+\"\\n from: \"+from_file)\n\traise FileNotFoundError(filename)","def insert_reference(self, reffile):\n header = self.get_refactor_header(reffile)\n return self.insert_header_reference(header, os.path.basename(reffile))","def _parse_reference_fofn( reference_fofn, target_locus ):\n log.info(\"Parsing reference sequence FOFN\")\n with open( reference_fofn, 'r' ) as handle:\n for line in handle:\n filename, locus = line.strip().split()\n print locus, target_locus\n if locus == target_locus:\n return filename\n msg = 'No fasta file for target locus found!'\n log.error( msg )\n raise ValueError( msg )","def get_refpaths_from_filename(filename, reference_file_types, observatory=None):\n from .. import datamodels\n with datamodels.open(filename) as model:\n refpaths = get_multiple_reference_paths(model, reference_file_types, observatory)\n return refpaths","def load(self) -> None:\n doc_ref = self.doc_ref\n if not isinstance(doc_ref, DocumentReference):\n return\n\n doc = doc_ref.get()\n if doc.exists:\n self.load_storage_model(doc.to_dict())","def from_file(cls, basename, *args, **keys):\n log.verbose(\"Loading mapping\", repr(basename), verbosity=55)\n path = keys.get(\"path\", None)\n if path:\n filename = os.path.join(path, os.path.basename(basename))\n basename = filename\n else:\n filename = config.locate_mapping(basename)\n text = utils.get_uri_content(filename)\n return cls.from_string(text, basename, *args, **keys)","def get_reference(self):\t\t\n\t\treturn self._reference","def get_load_references(self):\n for path, properties in self.load.items():\n yield CaseLoadReference(path=path, properties=list(properties))","def read_in_translate_vcf(vcf_file, ref_file, compressed=True):\n from Bio import SeqIO\n import numpy as np\n\n prots = {}\n\n posLoc = 0\n refLoc = 0\n altLoc = 0\n sampLoc = 9\n\n with open(vcf_file) as f:\n for line in f:\n if line[0] != '#':\n #actual data\n line = line.strip()\n dat = line.split('\\t')\n POS = int(dat[posLoc])\n REF = dat[refLoc]\n ALT = dat[altLoc].split(',')\n GEN = dat[0] #'CHROM' or the gene name here\n calls = np.array(dat[sampLoc:])\n\n #get samples that differ from Ref at this site\n recCalls = {}\n for sname, sa in zip(samps, calls):\n if sa != '.':\n recCalls[sname] = sa\n\n #store position and the altLoc\n for seq, gen in recCalls.iteritems():\n alt = str(ALT[int(gen[0])-1]) #get the index of the alternate\n ref = REF\n pos = POS-1 #VCF numbering starts from 1, but Reference seq numbering\n #will be from 0 because it's python!\n gen = GEN #from CHROM, gene name\n\n if gen not in prots.keys():\n prots[gen] = {}\n prots[gen]['sequences'] = {}\n prots[gen]['positions'] = []\n prots[gen]['reference'] = ''\n if seq not in prots[gen]['sequences'].keys():\n prots[gen]['sequences'][seq] = {}\n\n #will never be insertion or deletion! because translation.\n prots[gen]['sequences'][seq][pos] = alt\n prots[gen]['positions'].append(pos)\n\n elif line[0] == '#' and line[1] == 'C':\n #header line, get all the information\n header = line.strip().split('\\t')\n posLoc = header.index(\"POS\")\n refLoc = header.index(\"REF\")\n altLoc = header.index(\"ALT\")\n sampLoc = header.index(\"FORMAT\")+1\n samps = header[sampLoc:]\n nsamp = len(samps)\n\n for refSeq in SeqIO.parse(translation_ref_file(path), format='fasta'):\n prots[refSeq.name]['reference'] = str(refSeq.seq)\n posN = np.array(prots[refSeq.name]['positions'])\n posN = np.unique(posN)\n prots[refSeq.name]['positions'] = np.sort(posN)\n\n return prots","def create_reference(filename):\n contigs = {}\n with open(filename, \"r\") as f:\n header = \"\"\n seq = \"\"\n for line in f:\n if line[0] == \">\":\n if header:\n contigs[header] = seq\n header = line[1:].rstrip()\n seq = \"\"\n else:\n seq += line.rstrip()\n\n return contigs","async def parse_ref_obj(self, line):\n try:\n val = line.split(b',')[-1].split(b'=')\n\n if val[0] == b'ReferenceLatitude':\n LOG.debug('Ref latitude found...')\n self.lat = float(val[1])\n\n elif val[0] == b'ReferenceLongitude':\n LOG.debug('Ref longitude found...')\n self.lon = float(val[1])\n\n elif val[0] == b'DataSource':\n LOG.debug('Ref datasource found...')\n self.datasource = val[1].decode('UTF-8')\n\n elif val[0] == b'Title':\n LOG.debug('Ref Title found...')\n self.title = val[1].decode('UTF-8')\n\n elif val[0] == b'Author':\n LOG.debug('Ref Author found...')\n self.author = val[1].decode('UTF-8')\n\n elif val[0] == b'RecordingTime':\n LOG.debug('Ref time found...')\n self.start_time = datetime.strptime(val[1].decode('UTF-8'),\n REF_TIME_FMT)\n\n self.all_refs = all(f\n for f in [self.lat and self.lon and self.start_time])\n if self.all_refs and not self.written:\n LOG.info(\"All Refs found...writing session data to db...\")\n sess_ser = self.ser()\n sql = f\"\"\"INSERT into session ({','.join(sess_ser.keys())})\n VALUES({','.join([\"$\"+str(i+1) for i, _ in enumerate(sess_ser.keys())])})\n RETURNING session_id\n \"\"\"\n self.session_id = await DB.fetchval(sql, *sess_ser.values())\n self.written = True\n LOG.info(\"Session session data saved...\")\n except IndexError:\n pass","def load(journal: Journal, file: Path) -> None:","def referenzdaten_einlesen(self):\n self.refdata = np.genfromtxt(self.referencefile, skip_header=1, usecols=np.asarray(self.referenzspalte))\n self.Referencedata = Reference()","def get_refs(genome_build, aligner, config):\n find_fn = _find_file(config[CONFIG_KEY], startswith=True)\n ref_prefix = sret.find_ref_prefix(genome_build, find_fn)\n return sret.standard_genome_refs(genome_build, aligner, ref_prefix, _list(config[CONFIG_KEY]))","def load_bib(bib_name):\n print(\"Reading BibTex File: {}\".format(bib_name))\n curdir = osp.abspath('.')\n bib_path = osp.join(curdir, bib_name)\n print(\"Path: {}\".format(bib_path))\n print('Creating library..')\n add_dir('library')\n with open(bib_path, 'r') as f:\n # txt = f.read()\n line = f.readline()\n i = 0\n start = False\n while line:\n i += 1\n if (line.find('@')==1) or start: # reading entry\n if start == False:\n filename = get_name(line)\n start = True\n if line.find('title')==1:\n link = get_link(line)\n if link is not None:\n savepath = osp.join(curdir, 'library', filename+'.pdf')\n save_pdf(link, savepath)\n if (line.find('}')==1): # end of entry\n start=False\n line = f.readline()\n print(i) # print line number","def getReference(self, data: ghidra.program.model.listing.Data, toAddress: ghidra.program.model.address.Address) -> ghidra.program.model.symbol.Reference:\n ...","def load_gene_ontology(self, file_path):\n\t\tpass","def Reference(self, default={}):\n return HEP.ReferenceHEPObject(self.data.get('reference', default))","def parseFasta(self, fastaRef):\n\n seq = \"\"\n prevId = \"\"\n with open(fastaRef, 'r') as f:\n\n for line in f:\n if \">\" == line[0]:\n # asserting the regex don't fail...\n found = GENEIDRULE.search(line)\n if(found):\n alternate = found.group(1)\n geneName = found.group(2)\n self._transcripts[alternate] = geneName\n else:\n print(\"EnsemblFasta: NOT FOUND\")\n print(line)\n exit()\n\n if(prevId and seq):\n geneName = self._transcripts[prevId]\n if geneName in self._genes:\n gene = self._genes[geneName]\n else:\n gene = Gene(geneName)\n self._genes[geneName] = gene\n\n gene.addTranscripts(prevId, seq)\n seq = \"\"\n prevId = alternate\n else:\n seq += line.rstrip(\"\\n\")\n gene.addTranscripts(prevId, seq)","def _process_references0(self, references):\n if \"zarr_consolidated_format\" in references:\n # special case for Ike prototype\n references = _unmodel_hdf5(references)\n self.references = references","def _process_dbxref(self):\n\n raw = '/'.join((self.rawdir, 'dbxref'))\n logger.info(\"processing dbxrefs\")\n line_counter = 0\n\n with open(raw, 'r') as f:\n filereader = csv.reader(f, delimiter='\\t', quotechar='\\\"')\n f.readline() # read the header row; skip\n for line in filereader:\n (dbxref_id, db_id, accession, version, description, url) = line\n # dbxref_id\tdb_id\taccession\tversion\tdescription\turl\n # 1\t2\tSO:0000000\t\"\"\n\n db_ids = { # the databases to fetch\n 50: 'PMID', # pubmed\n 68: 'RO', # obo-rel\n 71: 'FBdv', # FBdv\n 74: 'FBbt', # FBbt\n # 28:, # genbank\n 30: 'OMIM', # MIM\n # 38, # ncbi\n 75: 'ISBN', # ISBN\n 46: 'PMID', # PUBMED\n 51: 'ISBN', # isbn\n 52: 'SO', # so\n # 76, # http\n 77: 'PMID', # PMID\n 80: 'FBcv', # FBcv\n # 95, # MEDLINE\n 98: 'REACT', # Reactome\n 103: 'CHEBI', # Chebi\n 102: 'MESH', # MeSH\n 106: 'OMIM', # OMIM\n 105: 'KEGG-path', # KEGG pathway\n 107: 'DOI', # doi\n 108: 'CL', # CL\n 114: 'CHEBI', # CHEBI\n 115: 'KEGG', # KEGG\n 116: 'PubChem', # PubChem\n # 120, # MA???\n 3: 'GO', # GO\n 4: 'FlyBase', # FlyBase\n # 126, # URL\n 128: 'PATO', # PATO\n # 131, # IMG\n 2: 'SO', # SO\n 136: 'MESH', # MESH\n 139: 'CARO', # CARO\n 140: 'NCBITaxon', # NCBITaxon\n # 151, # MP ???\n 161: 'DOI', # doi\n 36: 'BDGP', # BDGP\n # 55, # DGRC\n # 54, # DRSC\n # 169, # Transgenic RNAi project???\n 231: 'RO', # RO ???\n 180: 'NCBIGene', # entrezgene\n # 192, # Bloomington stock center\n 197: 'UBERON', # Uberon\n 212: 'ENSEMBL', # Ensembl\n # 129, # GenomeRNAi\n 275: 'PMID', # PubMed\n 286: 'PMID', # pmid\n 264: 'HGNC',\n # 265: 'OMIM', # OMIM_Gene\n 266: 'OMIM', # OMIM_Phenotype\n 300: 'DOID', # DOID\n 302: 'MESH', # MSH\n 347: 'PMID', # Pubmed\n }\n\n if accession.strip() != '' and int(db_id) in db_ids:\n # scrub some identifiers here\n m = re.match(\n r'(doi|SO|GO|FBcv|FBbt_root|FBdv|FBgn|FBdv_root|FlyBase|FBbt):',\n accession)\n if m:\n accession = re.sub(m.group(1)+r'\\:', '', accession)\n elif re.match(\n r'(FlyBase miscellaneous CV|cell_lineprop|relationship type|FBgn$)',\n accession):\n continue\n elif re.match(r'\\:', accession): # starts with a colon\n accession = re.sub(r'\\:', '', accession)\n elif re.search(r'\\s', accession):\n # skip anything with a space\n # logger.debug(\n # 'dbxref %s accession has a space: %s',\n # dbxref_id, accession)\n continue\n\n if re.match(r'http', accession):\n did = accession.strip()\n else:\n prefix = db_ids.get(int(db_id))\n did = ':'.join((prefix, accession.strip()))\n if re.search(r'\\:', accession) and prefix != 'DOI':\n logger.warning(\n 'id %s may be malformed; skipping', did)\n\n self.dbxrefs[dbxref_id] = {db_id: did}\n\n elif url != '':\n self.dbxrefs[dbxref_id] = {db_id: url.strip()}\n else:\n continue\n\n # the following are some special cases that we scrub\n if int(db_id) == 2 \\\n and accession.strip() == 'transgenic_transposon':\n # transgenic_transposable_element\n self.dbxrefs[dbxref_id] = {db_id: 'SO:0000796'}\n\n line_counter += 1\n\n return","def open_ref(self, ref, accept_string=False, make_sweetheart=False):\n ref = self.task_record.retrieve_ref(ref)\n if not accept_string: \n ctx = retrieve_filename_for_ref(ref, self.task_record, return_ctx=True)\n else:\n ctx = retrieve_file_or_string_for_ref(ref, self.task_record)\n if ctx.completed_ref is not None:\n if make_sweetheart:\n ctx.completed_ref = SW2_SweetheartReference.from_concrete(ctx.completed_ref, get_own_netloc())\n self.task_record.publish_ref(ctx.completed_ref)\n return ctx.to_safe_dict()","def _import(file_path):\n proxy_factory.import_proxies(open(file_path, 'r'))","def read_content_load(self, filename):\n str_file_woc = self.import_file(filename)\n self.parse_load(str_file_woc)\n self.disp_load_info()","def read_reference_data():\n return {f:read_local_file(f) for f in os.listdir(DATA_DIR)}","def populateReference(self, reference_data_folder=None):\n if reference_data_folder is None:\n reference_data_folder = os.path.join(\"..\", \"default_data\")\n\n files = os.listdir(reference_data_folder)\n\n reference_tables = []\n # Create reference table list\n with self.session_scope() as session:\n self.setupTabletypeMap()\n reference_table_objects = self.metaClasses[TableTypes.REFERENCE]\n for object in list(reference_table_objects):\n reference_tables.append(object.__tablename__)\n\n reference_files = [file for file in files if os.path.splitext(file)[0] in reference_tables]\n for file in reference_files:\n # split file into filename and extension\n table_name, _ = os.path.splitext(file)\n possible_method = 'addTo' + table_name\n method_to_call = getattr(self, possible_method, None)\n if method_to_call:\n with open(os.path.join(reference_data_folder, file), 'r') as f:\n reader = csv.reader(f)\n # skip header\n _ = next(reader)\n with self.session_scope() as session:\n for row in reader:\n # this solves error of add functions which take one\n # value instead of list of strings\n if len(row) == 1:\n method_to_call(row[0])\n else:\n method_to_call(*row)\n else:\n print(f\"Method({possible_method}) not found!\")","def from_path(cls, ref_full_path, **kwargs):\n try:\n with open(ref_full_path) as fp:\n obj = yaml.load(fp, Loader=YamlLoader)\n _kwargs = {key: value for key, value in obj.items() if key not in ('data', 'from_base64')}\n kwargs.update(_kwargs)\n return cls(obj['data'], from_base64=True, **kwargs)\n\n except IOError as ex:\n if ex.errno == errno.ENOENT:\n return None","def add_references_to_papers(infile, dir):\n papers = json.load(open(infile))\n for paper in papers:\n for file in os.listdir(dir):\n if file.split(\".txt\")[0] == paper['doi']: # Must find the correct file to parse\n filename = TEXT_DIR+file\n refs =extract_references_from_txt(filename) #Uses the text files to find references\n paper['references']=refs\n return papers","def get_actual_ref(self, ref):\n while ref in self.reference_map:\n ref = self.reference_map[ref]\n return ref","def create_reference(\n self, response_checker=default_checker.default_journey_checker\n ):\n # Check that the file doesn't already exist\n filename = self.get_file_name()\n filepath = os.path.join(config[\"REFERENCE_FILE_PATH\"], filename)\n\n if os.path.isfile(filepath):\n logger.warning(\n \"NO REF FILE CREATED - {} is already present\".format(filepath)\n )\n else:\n # Concatenate reference file info\n reference_text = OrderedDict()\n reference_text[\"query\"] = self.query.replace(\n config[\"URL_JORMUN\"][7:], \"localhost\"\n )\n logger.warning(\"Query: {}\".format(self.query))\n reference_text[\"response\"] = response_checker.filter(\n json.loads(self.full_resp)\n )\n reference_text[\"full_response\"] = json.loads(\n self.full_resp.replace(config[\"URL_JORMUN\"][7:], \"localhost\")\n )\n\n # Write reference file directly in the references folder\n with open(filepath, \"w\") as ref:\n ref.write(json.dumps(reference_text, indent=4))\n logger.info(\"Created reference file : {}\".format(filepath))","def fetchReferences(self, dataRef, exposure):\n skyMap = dataRef.get(self.dataPrefix + \"skyMap\", immediate=True)\n tractInfo = skyMap[dataRef.dataId[\"tract\"]]\n patch = tuple(int(v) for v in dataRef.dataId[\"patch\"].split(\",\"))\n patchInfo = tractInfo.getPatchInfo(patch)\n references = lsst.afw.table.SourceCatalog(self.references.schema)\n references.extend(self.references.fetchInPatches(dataRef, patchList=[patchInfo]))\n return references","def extract_references(content):\n references = {}\n content = content.replace(\"\\n\", \"\\\\n\")\n matches = re.findall('(\\[[0-9]+\\][^\\[]*?(?=\\[|Acknowledge|Fig|Table|Conclusion|pdf))', content)\n if matches:\n for match in matches:\n ref_id = get_reference_id(match)\n # No reference id exist -- skip it\n if ref_id != -1:\n value = match.replace('\\\\n', '\\n')\n references[ref_id] = value\n return references","def test_load_ref_mask():\n\n itraj = os.path.join(path, \"alanine_dipeptide.nc\")\n iref = os.path.join(path, \"alanine_dipeptide.ncrst\")\n itop = os.path.join(path, \"alanine_dipeptide.parm7\")\n\n for mask in [\":ALA,ACE,NME\", \"!:WAT\"]:\n traj = tools.load_traj(itraj, itop, mask)\n\n with pytest.raises(ValueError):\n ref = tools.load_ref(itraj, itop, mask)\n\n ref = tools.load_ref(iref, itop, mask)\n\n assert ref.n_frames == 1\n assert ref.n_atoms == 22","def read_file(path):\n # Mystery arguments:\n strictness = False\n # Read the string:\n return _iterate_bibtexsource(_bibtex.open_file(path, strictness))","def load_knowledge(net, filepath):\n\treloaded = loadz(filepath)\n\tknowledge = [(name, reloaded[name]) for name in sorted(reloaded.keys())]\n\tset_knowledge(net, knowledge)","def add_file_ref(self, file_name: str) -> None:\n self.referenced_in.add(file_name)","def get_reference_list(reference_sequences_path):\n\n\ttry:\n\t\tinfile = open(reference_sequences_path, \"rU\")\n\t\tsequences = infile.read()\n\t\treference_sequences = sequences.splitlines()\n\t\tinfile.close()\n\t\treturn reference_sequences\n\texcept IOError as e:\n\t\tprint(str(e))\n\t\tsys.exit(1) # Aborts program. (exit(1) indicates that an error occurred)","def load_fileaccess(cls, trial_ref, session=None):\n session = session or relational.session\n result = session.query(cls.m).filter(cls.m.trial_id == trial_ref)\n return result.first()","def __init__(self, file_path):\n self.file_path = file_path\n try:\n self.FastaFile = pysam.FastaFile(self.file_path)\n except:\n raise IOError(\"REFERENCE FILE ERROR\")","def get_Tref(self,typ,file_number):\n if typ == 'emis':\n return self.beam_emis[file_number].T_ref\n elif typ == 'atte':\n return self.beam_atte[file_number].T_ref\n else:\n raise NameError('No list with this name: {0}'.format(typ))","def open_ref(self, ref):\n ref = self.task_record.retrieve_ref(ref)\n return self.block_store.retrieve_filename_for_ref(ref)","def get_reference_datetime(file):\n date_string = file.root.discharge1._f_getAttr('reference_datetime')[0]\n ref_date = datetime.datetime.strptime(date_string, '%d-%b-%Y;%H:%M:%S.%f')\n\n return ref_date","def fetch_genome(reference_name):\n from utils import script_dir\n genome_list = yaml.load(open(script_dir + \"/utils/genomes.yaml\",\"r\"))\n makedir(\"genomes\")\n if reference_name not in genome_list:\n msg(\"Reference Genome not available\", \"error\")\n ftp_loc = genome_list[reference_name]\n filename = os.path.split(ftp_loc)[1]\n makedir(\"{script_dir}/genomes/{reference_name}\".format(**locals()))\n reference_loc = \"{script_dir}/genomes/{reference_name}/{filename}\".format(**locals())\n if not file_exists( reference_loc + \".sa\"):\n print(\"Downloading {filename}\".format(**locals()))\n os.system(\"curl {ftp_loc} > {script_dir}/genomes/{reference_name}/{filename}\".format(**locals()))\n # Unzip and rezip with bgzip\n if filename.endswith(\".gz\"):\n os.system(\"gunzip {reference_loc} && bgzip {reference_loc2}\".format(reference_loc=reference_loc, reference_loc2=reference_loc.replace(\".gz\",\"\")))\n print(\"Indexing {script_dir}/genomes/{reference_name}/{filename}\".format(**locals()))\n os.system(\"bwa index {script_dir}/genomes/{reference_name}/{filename}\".format(**locals()))\n else:\n msg(\"Reference Already downloaded and indexed.\", \"error\")","def load_replace_candidate(self, filename=None, config=None):\n raise NotImplementedError","def make_reference(reference_path, reference_meta, model):\n # Make file dirs\n reference_dirs = list(reference_meta.keys())\n ids = []\n \n # Get file fullpath\n files = []\n import glob\n if DEBUG:\n for refdir in reference_dirs[:20]:\n foundfiles = glob.glob(os.path.join(reference_path, refdir, \"*jpg\"))\n files.extend(foundfiles)\n for _ in foundfiles:\n ids.append(refdir)\n else:\n for refdir in reference_dirs:\n foundfiles = glob.glob(os.path.join(reference_path, refdir, \"*jpg\"))\n files.extend(foundfiles)\n for _ in foundfiles:\n ids.append(refdir)\n dataset = buzaiDataset(files, transforms_val)\n loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, sampler=SequentialSampler(dataset), num_workers=num_workers)\n\n # Get embeddings\n embeddings = predict(loader, files, model)\n \n return embeddings, np.array(ids)","def ProcessEntryFile(fd):\n\tglobal reference\n\n\tname = ''\n\tfilename = ''\n\tdd = {}\n\teof = False\n\twhile not eof:\n\t\tline = fd.readline()\n\t\tif len(line) == 0:\n\t\t\teof = True\n\t\t\tif name in reference.keys():\n\t\t\t\treference[name] = dd\n\t\t\telif name != '':\n\t\t\t\treference[name] = dd\n\t\t\t#if verbose: print reference\n\t\telse:\n\t\t\tline = line.strip()\n\t\t\tif line.startswith('name'):\n\t\t\t\tif name in reference.keys() or name != '':\n\t\t\t\t\treference[name] = dd\n\t\t\t\ttokens = line.split()\n\t\t\t\tnn = tokens[0].split('=')\n\t\t\t\tname = nn[1]\n\t\t\t\tdd = {}\n\t\t\telif line.startswith('file'):\n\t\t\t\tfilename = line[len('file='):]\n\t\t\t\tif name in reference.keys():\n\t\t\t\t\tdd \t= reference[name]\n\t\t\t\t\tif dd.has_key(filename):\n\t\t\t\t\t\tfilename = ''\n\t\t\telse:\n\t\t\t\tif filename != '':\n\t\t\t\t\ttokens = line.split()\n\t\t\t\t\tlength = len(tokens)\n\t\t\t\t\t#print tokens\n\t\t\t\t\tfirst = True\n\t\t\t\t\tfor t in range(0,length,2):\n\t\t\t\t\t\tpos = tokens[t].find('=')\n\t\t\t\t\t\tcountline = int(tokens[t][pos+1:])\n\t\t\t\t\t\tpos = tokens[t+1].find('=')\n\t\t\t\t\t\tref = tokens[t+1][pos+1:]\n\t\t\t\t\t\ttline = (countline,ref)\n\t\t\t\t\t\tif first:\n\t\t\t\t\t\t\tdd[filename] = [tline]\n\t\t\t\t\t\t\tfirst = False\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tff = dd[filename] #list of tuples (line,ref)\t\t\t\t\n\t\t\t\t\t\t\tff.append(tline)\n\t\t\t\t\t\t\tdd[filename] = ff","def unwrap(xml_file, missing_message=\"NO TRANSLATION AVAILABLE\"):\n tree = ET.parse(xml_file) \n\n # Find and check the source langs, ref langs and translators\n src_langs, ref_langs, translators = set(), set(), set()\n\n for src_doc in tree.getroot().findall(\".//src\"):\n src_langs.add(src_doc.get(\"lang\"))\n\n for ref_doc in tree.getroot().findall(\".//ref\"):\n ref_langs.add(ref_doc.get(\"lang\"))\n translator = ref_doc.get(\"translator\")\n if translator: translators.add(translator)\n \n if len(src_langs) > 1:\n raise RuntimeError(\"Multiple source languages found\")\n\n if len(src_langs) == 0:\n raise RuntimeError(\"No source languages found\")\n\n src_lang = src_langs.pop()\n src = []\n\n if len(ref_langs) > 1:\n raise RuntimeError(\"Multiple reference languages found -- this case is not currently handled\")\n\n\n if len(ref_langs) > 0:\n if len(translators) == 0:\n LOG.info(\"No translator identifiers found -- reading first translation for each document\")\n translators.add(DEFAULT_TRANSLATOR)\n ref_lang = ref_langs.pop()\n ref = {translator : [] for translator in translators}\n else:\n LOG.info(\"No references found\")\n ref_lang = None\n ref = {}\n\n\n # Extract text\n src_sent_count,doc_count = 0,0\n for doc in tree.getroot().findall(\".//doc\"):\n doc_count += 1\n src_sents = {int(seg.get(\"id\")): seg.text for seg in doc.findall(\".//src//seg\")}\n if ref_lang: \n ref_docs = doc.findall(\".//ref\")\n trans_to_ref = {}\n\n # If no translator identifiers, we just read one reference (if any) \n # If there are translator identifiers, we add a reference for each translator\n\n def get_ref_sents(ref_doc):\n return {int(seg.get(\"id\")): seg.text for seg in ref_doc.findall(f\".//seg\")}\n\n if len(translators) == 1 and DEFAULT_TRANSLATOR in translators:\n if len(ref_docs):\n trans_to_ref[DEFAULT_TRANSLATOR] = get_ref_sents(ref_docs[0])\n else:\n trans_to_ref[DEFAULT_TRANSLATOR] = {}\n else:\n trans_to_ref = {ref_doc.get(\"translator\"): get_ref_sents(ref_doc) for ref_doc in ref_docs}\n\n for seg_id in sorted(src_sents.keys()):\n src.append(src_sents[seg_id])\n src_sent_count += 1\n if ref_lang:\n for translator in translators:\n ref[translator].append(trans_to_ref.get(translator, {translator: {}}).get(seg_id, missing_message))\n\n LOG.info(f\"Extracted {doc_count} document(s) containing {src_sent_count} sentences in {src_lang}\")\n\n\n return src_lang,src,ref_lang,ref","def load(self, filename):\n raise NotImplementedError","def read_in_file(self, file):\n with open(self.file) as doc:\n trie = dict()\n for line in doc:\n line = line.split(' ')[0]\n self.make_trie(trie, line.rstrip())\n return trie","def load(self):\r\n self.read(self.filename)","def __init__(self, url):\n\n lines = [l.strip().split() for l in open(url)]\n\n # Split the lines and the headers\n i = 0\n self.refs = {} # name: [len, offset-to-first-record, offset-to-last-record + 1]\n\n while(lines[i][0][0] == '@'):\n line = lines[i]\n if line[0] == '@SQ':\n sn = line[1].split(':')[1]\n ln = int(line[2].split(':')[1])\n self.refs[sn] = [ln, None, None]\n i += 1\n\n # Process the mapped reads\n # - create offset pointers to the start of each chromosome\n # - convert the position to an int\n cur_chr = lines[i][2]\n self.refs[cur_chr][1] = i\n \n while(i < len(lines)):\n if not (int(lines[i][1]) & 0x4): \n lines[i][3] = int(lines[i][3])\n\n if lines[i][2] != cur_chr:\n self.refs[cur_chr][2] = i # mark the end\n cur_chr = lines[i][2] \n self.refs[cur_chr][1] = i # mark the start\n i += 1\n\n self.lines = lines\n \n return","def read_from_file(self, filename: str) -> None:","def load(filepath: str) -> Torrent:\n # open .torrent file for binary reading\n with open(filepath, 'rb') as f:\n content = f.read()\n\n # decode the B-encoded content\n meta_info = decoder.decode(content)\n \n # create Torrent object\n t = Torrent(meta_info)\n return t","def load_lookup_table(path):\n assert os.path.exists(path), \"Lookup table file not found.\"\n with open(path, \"rb\") as dillfile:\n return dill.load(dillfile)","def __loadFromFile(self):\n try:\n f=open(self.__fileR, \"r\")\n line =f.readline().strip()\n rez=[]\n while line!=\"\":\n attrs=line.split(\",\")\n rt=Rent(attrs[0], attrs[1], attrs[2], attrs[3])\n rez.append(rt)\n line=f.readline().strip()\n f.close()\n return rez\n #the file cannot be reached\n except IOError:\n return None","def load(filename):\r\n wholeTract= nib.streamlines.load(filename) \r\n wholeTract = wholeTract.streamlines\r\n return wholeTract","async def load(self, file: IO) -> dict:","def load(filename):\n o = open(filename)\n s = o.read()\n a = ArffFile.parse(s)\n o.close()\n return a","def scan_line(line):\n URL = None\n type = None\n # Check for direct URL first\n match = re.search(MATCH_URL, line)\n if match:\n return match.group(0)\n # Check for reference URL \n match = re.match(MATCH_REF_URL, line)\n if not match:\n return None\n # So, it's a reference, scan doc for corresponding URL\n return expand_reference(match.group(1))","def _dereference(self, ref_url, obj_path, recursions):\n # In order to start dereferencing anything in the referenced URL, we have\n # to read and parse it, of course.\n contents = _url.fetch_url(ref_url, self.__reference_cache, self.__encoding)\n\n # In this inner parser's specification, we can now look for the referenced\n # object.\n value = contents\n if len(obj_path) != 0:\n from prance.util.path import path_get\n try:\n value = path_get(value, obj_path)\n except (KeyError, IndexError, TypeError) as ex:\n raise _url.ResolutionError('Cannot resolve reference \"%s\": %s'\n % (ref_url.geturl(), str(ex)))\n\n # Deep copy value; we don't want to create recursive structures\n import copy\n value = copy.deepcopy(value)\n\n # Now resolve partial specs\n value = self._resolve_partial(ref_url, value, recursions)\n\n # That's it!\n return value","def import_gff(file, genome_version, verbose = False):\n \n from tridentdb import models\n import re\n from django.db.utils import DatabaseError\n \n if genome_version == None:\n print(\"Genome Version is needed for loading a gff file.\")\n return\n\n genomes = models.Genome.objects.filter(genome_ver = genome_version)\n if len(genomes) == 0:\n print(\"Unknown Genome Version: %s\" % genome_version)\n return\n \n lineno = 1\n for line in file:\n if verbose:\n print(\"Line Number: %d\" % lineno)\n lineno += 1\n if not line:\n continue\n line = line.strip()\n if line[0] == '#':\n continue\n info = line.split('\\t')\n chromosome = info[0].replace(\"chr\", \"\")\n is_primary_transcript = (info[2] == 'miRNA_primary_transcript')\n genomic_mir_start = info[3]\n genomic_mir_end = info[4]\n is_on_positive_strand = (info[6] == '+')\n \n mirbase_id = mirbase_acc = mirbase_name = mirbase_derives_from = None\n mirbase = info[8].split(';')\n for tag in mirbase:\n (name, val) = tag.split('=')\n if name == \"ID\":\n mirbase_id = val\n elif name == \"accession_number\":\n mirbase_acc = val\n elif name == \"Alias\":\n # Use alias for accession_number IFF accession_number\n # is not used\n if not mirbase_acc:\n mirbase_acc = val\n elif name == \"Name\":\n mirbase_name = val\n elif name == \"derives_from\":\n mirbase_derives_from = val\n else:\n print(\"Unknown Mirbase tag: \\\"%s\\\"\" % name)\n continue\n\n mirna = models.MicroRNA(chromosome=chromosome, is_primary_transcript = is_primary_transcript, genomic_mir_start = genomic_mir_start, genomic_mir_end = genomic_mir_end, is_on_positive_strand = is_on_positive_strand, mirbase_id = mirbase_id, mirbase_acc = mirbase_acc, mirbase_name = mirbase_name, mirbase_derives_from = mirbase_derives_from, genome = genomes[0] )\n \n try:\n mirna.save()\n except DatabaseError as de:\n from sys import stderr\n stderr.write(\"Error loading GFF line: {0}\\n\".format(line))\n raise de\n ##end of import_gff","def read_relations(db, openfile):\n pass","def load(self, filepath):\n _ = filepath\n return self"],"string":"[\n \"def load_reference(self, path_to_reference):\\n with open(path_to_reference,'r') as f:\\n qids_to_relevant_docids = self.load_reference_from_stream(f)\\n return qids_to_relevant_docids\",\n \"def test_load_ref():\\n\\n itraj = os.path.join(path, \\\"alanine_dipeptide.nc\\\")\\n iref = os.path.join(path, \\\"alanine_dipeptide.ncrst\\\")\\n itop = os.path.join(path, \\\"alanine_dipeptide.parm7\\\")\\n\\n with pytest.raises(ValueError):\\n ref = tools.load_ref(itraj, itop)\\n\\n ref = tools.load_ref(iref, itop)\\n\\n assert ref.n_frames == 1\\n assert ref.n_atoms == 1912\",\n \"def _load_ref(self, ref_uri, session):\\n if self.verbose:\\n print(\\\"Resolving $ref URI {}\\\".format(ref_uri), file=sys.stderr)\\n parsed_ref_uri = self._parse_ref_uri(ref_uri)\\n ref_file = parsed_ref_uri.netloc + parsed_ref_uri.path\\n if not ref_file: # must be relative to current doc\\n pass # is already in cache\\n elif ref_file not in self.cache:\\n self.cache[ref_uri] = self._load_for_cache(parsed_ref_uri, session)\\n ref_json = self.cache[ref_uri]\\n expr = jsonpath_rw.parse(\\\"$\\\" + \\\".\\\".join(parsed_ref_uri.fragment.split(\\\"/\\\")))\\n for match in expr.find(ref_json):\\n return match.value # return first match only\\n # If we reach here, resolution failed\\n raise RefResolutionException('Could not resolve reference URI \\\"{}\\\"'.format(ref_uri))\",\n \"def extract_references_from_txt(filename):\\n file = open(filename)\\n references_section = \\\"\\\"\\n references_section_found = False\\n for line in file:\\n if \\\"REFERENCE\\\" in line:\\n references_section_found = True\\n if references_section_found:\\n references_section+=line + \\\" \\\"\\n references_section = references_section.replace('\\\\n','')\\n refs = extract_references(references_section)\\n return refs\",\n \"def _load_ref(self, doc_uri, doc, ref_uri):\\n if self.verbose:\\n print('Resolving $ref URI {}'.format(ref_uri), file=sys.stderr)\\n parsed_ref_uri = self._parse_ref_uri(ref_uri)\\n ref_file = parsed_ref_uri.netloc + parsed_ref_uri.path\\n if not ref_file: # must be relative to current doc\\n pass # is already in cache\\n elif ref_file not in self.cache:\\n self.cache[ref_uri] = self._load_for_cache(\\n doc_uri, doc, parsed_ref_uri)\\n ref_json = self.cache[ref_uri]\\n expr = jsonpath_rw.parse(\\n '$' + '.'.join(parsed_ref_uri.fragment.split('/')))\\n for match in expr.find(ref_json):\\n return match.value # return first match only\\n # If we reach here, resolution failed\\n raise RefResolutionException(\\n 'Could not resolve reference URI \\\"{}\\\"'.format(ref_uri))\",\n \"def load_references(self, collections, item):\",\n \"def refl_load(file_descriptors):\\n modules = [{\\\"module\\\": \\\"ncnr.refl.load\\\", \\\"version\\\": \\\"0.1\\\", \\\"config\\\": {}}]\\n template = Template(\\\"test\\\", \\\"test template\\\", modules, [], \\\"ncnr.magik\\\", version='0.0')\\n retval = process_template(template, {0: {\\\"files\\\": file_descriptors}}, target=(0, \\\"output\\\"))\\n return retval.todict()\",\n \"def parseReference(self):\\n libxml2mod.xmlParseReference(self._o)\",\n \"def resolve_reference(self, key, filetype=None):\\n return self.__resolve_reference(\\n key,\\n self.get_metainfo().get(key), # TODO: use Java method with metaKey instead of getting metainfo here\\n checked_filetype(filetype)\\n )\",\n \"def load_conanfile(self, conanfile_path, ref, graph_lock=None, remotes=None,\\n update=None, check_update=None):\\n try:\\n conanfile, _ = self.load_basic_module(conanfile_path, graph_lock, str(ref), remotes,\\n update=update, check_update=check_update)\\n except Exception as e:\\n raise ConanException(\\\"%s: Cannot load recipe.\\\\n%s\\\" % (str(ref), str(e)))\\n\\n conanfile.name = ref.name\\n conanfile.version = str(ref.version)\\n conanfile.user = ref.user\\n conanfile.channel = ref.channel\\n return conanfile\",\n \"def ref(request):\\n r = referencepytest.ref(request)\\n this_dir = os.path.abspath(os.path.dirname(__file__))\\n r.set_data_location(os.path.join(this_dir, '..', 'reference'))\\n return r\",\n \"def read_refcopy(f):\\n\\n d_refcopy = {}\\n for n, line in enumerate(open(f)):\\n if line.startswith('#'):\\n continue\\n\\n line = line.rstrip()\\n if line == '':\\n continue\\n\\n _lis = line.split('\\\\t')\\n taxa, num, = _lis[:2]\\n skip = False\\n for word in EXCLUDE:\\n if word in taxa:\\n skip = True\\n break\\n\\n if skip:\\n continue \\n\\n # the parsing of taxa works for both mothur output and this\\n taxa = taxa.rstrip(';') # for mothur classfy.seqs output\\n lis = taxa.split(';')\\n lis2 = []\\n for item in lis:\\n item = item.strip() # for copyrigher copy table ' ;' separater\\n if item.endswith(')'):\\n item = item.rsplit('(', 1)[0].strip()\\n\\n # remove taxon level prefix, e.g. 'p__Firmicutes'\\n if '__' in item:\\n item = item.split('__', 1)[1]\\n\\n #item = item.strip('\\\"')\\n\\n # green gene taxonomy has sapce\\n item = item.replace(' ', '_')\\n\\n item = item.lower()\\n if item in ['', 'unknown', 'other', 'unassigned']:\\n item = 'Unclassifed'\\n\\n item = item.capitalize()\\n lis2.append(item)\\n\\n length = len(lis2)\\n assert length <= LEVELS, '> {} levels found ({})'.format(\\n LEVELS, length)\\n if length != LEVELS:\\n lis2 = lis2 + ['Unclassified']*(LEVELS - length)\\n\\n tu = tuple(lis2)\\n d_refcopy[tu] = float(num)\\n\\n return d_refcopy\",\n \"def load_reference_from_stream(self, f):\\n qids_to_relevant_docids = {}\\n for l in f:\\n vals = l.strip().split('\\\\t')\\n if len(vals) != 4:\\n vals = l.strip().split(' ')\\n if len(vals) != 4:\\n pdb.set_trace()\\n raise IOError('\\\\\\\"%s\\\\\\\" is not valid format' % l)\\n\\n qid = vals[0]\\n if qid in qids_to_relevant_docids:\\n pass\\n else:\\n qids_to_relevant_docids[qid] = []\\n _rel = int(vals[3])\\n if _rel > 0:\\n qids_to_relevant_docids[qid].append(vals[2])\\n\\n return qids_to_relevant_docids\",\n \"def referenced_by(self, refobj):\\n try:\\n ref = cmds.referenceQuery(refobj, referenceNode=True)\\n return ref\\n except RuntimeError as e:\\n if str(e).endswith(\\\"' is not from a referenced file.\\\\n\\\"):\\n return None\\n else:\\n raise e\",\n \"def load(self, reference_file=None):\\n lake = self.services.lake\\n\\n if reference_file is None:\\n reference_file = self.get_local_path(self.filename_reference)\\n\\n logging.info(\\n f\\\"ModelContainer {self.name} loading container from {reference_file}\\\"\\n )\\n with open(reference_file) as f:\\n reference = json.load(f)\\n\\n # Load the distributions\\n dist_ref = reference[\\\"distributions\\\"]\\n dist_path = self.get_local_path(self.filename_distributions)\\n lake.download(dist_ref[\\\"path\\\"], dist_path)\\n self.load_distributions(dist_path)\\n\\n # Load the model\\n model_ref = reference[\\\"model\\\"]\\n model_path = self.get_local_path(self.filename_model)\\n lake.download(model_ref[\\\"path\\\"], model_path)\\n self.load_model()\",\n \"def read_refgene_file(self, file_path):\\n with open(file_path) as fi:\\n for line in fi:\\n content = line.strip().split()\\n refgene = RefGene()\\n refgene.bin = int(content[0])\\n refgene.name, refgene.chrom, refgene.strand = content[1], content[2].lower(), content[3]\\n refgene.tx_start, refgene.tx_end = int(content[4]), int(content[5])\\n refgene.cds_start, refgene.cds_end = int(content[6]), int(content[7])\\n refgene.exon_count = int(content[8])\\n refgene.exon_starts = [int(e) for e in content[9][:-1].split(',')]\\n refgene.exon_ends = [int(e) for e in content[10][:-1].split(',')]\\n refgene.core, refgene.name2 = int(content[11]), content[12]\\n refgene.cds_start_stat, refgene.cds_end_stat = content[13], content[14]\\n # refgene.exon_frames = [int(e) for e in content[15][:-1].split(',')]\\n self.ref_genes.append(refgene)\",\n \"def read_reference(conformation_fname):\\r\\n\\r\\n #Create empty set\\r\\n reference_atoms = []\\r\\n\\r\\n #Try/catch if file cannot be found. Open file in read mode\\r\\n #For eveyr line in the text file, strip all white spaces from front and back\\r\\n #If not empty line, split line on commas and put integers in set. These correspond to atom numbers of the key atoms\\r\\n #Return this list\\r\\n\\r\\n try:\\r\\n with open(conformation_fname, \\\"r\\\") as fin :\\r\\n num = 1\\r\\n for line in fin:\\r\\n if num < 10:\\r\\n num = num + 1\\r\\n continue\\r\\n content = line.strip()\\r\\n if content == '':\\r\\n continue\\r\\n else:\\r\\n reference_atoms.append(content.split())\\r\\n #reference_atom_num.update([int(i) for i in content.split(',')])\\r\\n return reference_atoms\\r\\n #Catch OS error\\r\\n except OSError:\\r\\n print('OS error')\\r\\n sys.exit()\\r\\n #Catch value error (not appropriate values to be converted to int)\\r\\n except ValueError:\\r\\n print('Could not convert data to integer')\\r\\n sys.exit()\",\n \"def _get_references_data(wit_path):\\n\\n with open(os.path.join(wit_path, '.wit', 'references.txt'), 'r') as data:\\n info = {'None': 'None'}\\n info.update({'HEAD': data.readline().split('=')[-1].strip('\\\\n')})\\n info.update({'master': data.readline().split('=')[-1].strip('\\\\n')})\\n for row in data.readlines():\\n name, commit_id = row.split('=')\\n info.update({name.strip('\\\\n'): commit_id.strip('\\\\n')})\\n\\n return info\",\n \"def load_from_folder(folder):\\n refs = []\\n for input_file in os.listdir(folder):\\n if input_file.endswith(\\\".ref\\\"):\\n refs.append(Reference(folder, input_file))\\n return refs\",\n \"def trieFromFile(fname_ref):\\n global gTrie\\n\\n with open(fname_ref) as f:\\n motifs = f.readlines() \\n # if first line already contains a motif, change 1 to 0 in line below\\n for m in motifs[1:]:\\n m = m.split(',')[0]\\n gTrie[m] = 1\",\n \"def load_ref_case(fname, name):\\r\\n with open(fname, 'rb') as f:\\r\\n\\r\\n a = np.load(f)\\r\\n\\r\\n data = a[name]\\r\\n \\r\\n return data\",\n \"def parse_ref_file(file, start_pos=2, end_pos=7):\\n data = []\\n ref_dict = {}\\n try:\\n with open(file) as f:\\n content = f.read()\\n data = [word for lines in content.split(';')[start_pos: end_pos] for word in lines.splitlines(True) if '=' in word]\\n for item in data:\\n k = item.split('=')[0].strip().strip(\\\"'\\\")\\n v = item.split('=')[1].strip().strip(\\\"'\\\") \\n if k not in ref_dict:\\n ref_dict[k] = v\\n except Exception as e:\\n logger.info('Failed to parse SAS dictionary...')\\n return {}\\n return ref_dict\",\n \"def get_reference_properties(filename):\\n try: # Hopefully it's a nice new standard filename, easy\\n return decompose_newstyle_name(filename)\\n except AssertionError: # cryptic legacy paths & names, i.e. reality\\n pass\\n # If not, dig inside the FITS file, slow\\n return ref_properties_from_header(filename)\",\n \"def extract_ref(line, refType):\\n target = '\\\\\\\\' + refType + '{'\\n\\n start = line.find(target)\\n for i in range(start, len(line)):\\n if line[i] == '}':\\n ref = line[start + len(target) : i]\\n break\\n return ref\",\n \"def test_references(self):\\n with sphinx_build('pyexample'):\\n with open('_build/text/docfx_yaml/example.example.yml') as yml_file:\\n data = yaml.safe_load(yml_file)\\n # Test that references are properly put at the top-level\\n self.assertTrue(\\n 'references' in data\\n )\\n # Check reference parent\\n self.assertEqual(\\n data['references'][0]['parent'],\\n 'example.example'\\n\\n )\",\n \"def fetch_reads_from_reference(self, ref):\\n try:\\n print(\\\"Fetching reads from object {}\\\".format(ref))\\n reads_client = ReadsUtils(self.callback_url)\\n reads_dl = reads_client.download_reads({\\n \\\"read_libraries\\\": [ref],\\n \\\"interleaved\\\": \\\"false\\\"\\n })\\n pprint(reads_dl)\\n reads_files = reads_dl['files'][ref]['files']\\n ret_reads = {\\n \\\"object_ref\\\": ref,\\n \\\"style\\\": reads_files[\\\"type\\\"],\\n \\\"file_fwd\\\": reads_files[\\\"fwd\\\"]\\n }\\n if reads_files.get(\\\"rev\\\", None) is not None:\\n ret_reads[\\\"file_rev\\\"] = reads_files[\\\"rev\\\"]\\n return ret_reads\\n except:\\n print(\\\"Unable to fetch a file from expected reads object {}\\\".format(ref))\\n raise\",\n \"def loadReferenceContigs(referencePath, alignmentSet, windows=None):\\n # FIXME we should get rid of this entirely, but I think it requires\\n # fixing the inconsistency in how contigs are referenced here versus in\\n # pbcore.io\\n\\n # Read contigs from FASTA file (or XML dataset)\\n refReader = ReferenceSet(referencePath)\\n contigs = []\\n if windows is not None:\\n refNames = set([rw.refName for rw in windows])\\n for contig in refReader:\\n if contig.id in refNames:\\n contigs.append(contig)\\n else:\\n contigs.extend([x for x in refReader])\\n contigDict = dict([(x.id, x) for x in contigs])\\n\\n # initially each contig has an id of None -- this will be overwritten with the id from the cmp.h5, if there are any\\n # reads mapped to it.\\n for x in contigs:\\n x.cmph5ID = None\\n\\n # Mark each contig with it's ID from the cmp.h5 - match them up using MD5s\\n for x in alignmentSet.referenceInfoTable:\\n if x.FullName in contigDict:\\n contigDict[x.FullName].cmph5ID = x.ID\\n\\n return contigs\",\n \"def reloadReference(*args):\\n \\n sel = cmds.textScrollList(widgets[\\\"shotAssListTSL\\\"], q=True, si=True)\\n if sel:\\n for s in sel:\\n path = pi.referenceDictionary[s]\\n cmds.file(path, loadReference=True)\\n\\n populateSceneRefs()\",\n \"def get_reference_file(dataset, reference_file_type, observatory=None, asn_exptypes=None):\\n if isinstance(dataset, str):\\n from jwst import datamodels\\n with datamodels.open(dataset, asn_exptypes=asn_exptypes) as model:\\n return get_multiple_reference_paths(\\n model, [reference_file_type], observatory)[reference_file_type]\\n else:\\n return get_multiple_reference_paths(\\n dataset, [reference_file_type], observatory)[reference_file_type]\",\n \"def read_gitref():\\n\\n gitref = module.directory.joinpath('.gitref')\\n if gitref.is_file():\\n with gitref.open('r') as fp:\\n return fp.read().strip()\\n return '<unknown_gitref>'\",\n \"def retrieve(dbxrefs, basics=True, hierarchy=True, wikipedia=True, literature=True, cross_references=True, overlaps=True):\\n resolved = dbxref.resolver.resolve(dbxrefs, check_existence=False)\\n documents = []\\n for entry in resolved:\\n # Construct URL for retrieve\\n json_url = entry['locations']['json'][0]\\n logger.debug('URL: %s', json_url)\\n r = requests.get(json_url)\\n logger.debug('Content: %s', r.text)\\n ipro = json.loads(r.text)\\n\\n # Parse retrieved json file by selected Options\\n output = {\\\"id\\\": entry[\\\"dbxref\\\"]}\\n if basics:\\n try:\\n output.update(accession=ipro[\\\"metadata\\\"][\\\"accession\\\"], entry_type=ipro[\\\"metadata\\\"][\\\"type\\\"],\\n description=ipro[\\\"metadata\\\"][\\\"description\\\"], counters=ipro[\\\"metadata\\\"][\\\"counters\\\"],\\n entry_id=ipro[\\\"metadata\\\"][\\\"entry_id\\\"], name=ipro[\\\"metadata\\\"][\\\"name\\\"],\\n source_database=ipro[\\\"metadata\\\"][\\\"source_database\\\"])\\n except KeyError:\\n logger.warning(\\\"One or more basic information were not available for the given entry. Please check your output.\\\")\\n if hierarchy:\\n try:\\n output.update(hierarchy=ipro[\\\"metadata\\\"][\\\"hierarchy\\\"])\\n except KeyError:\\n logger.warning(\\\"Hierarchy information was not available for the given entry.\\\")\\n if wikipedia:\\n try:\\n output.update(wikipedia=ipro[\\\"metadata\\\"][\\\"wikipedia\\\"])\\n except KeyError:\\n logger.warning(\\\"Wikipedia articles were not available for the given entry.\\\")\\n if literature:\\n try:\\n output.update(literature=ipro[\\\"metadata\\\"][\\\"literature\\\"])\\n except KeyError:\\n logger.warning(\\\"Literature was not available for the given entry.\\\")\\n if cross_references:\\n try:\\n output.update(cross_references=ipro[\\\"metadata\\\"][\\\"cross_references\\\"])\\n except KeyError:\\n logger.warning(\\\"Cross_references were not available for the given entry.\\\")\\n if overlaps:\\n try:\\n output.update(overlaps=ipro[\\\"metadata\\\"][\\\"overlaps_with\\\"])\\n except KeyError:\\n logger.warning(\\\"Overlap information was not available for the given entry.\\\")\\n documents.append(output)\\n return documents\",\n \"def prepare_reference(reference_fp):\\n # create .fai if doesn't yet exist\\n if not os.path.isfile(re.sub(r'.[^.]*$', '.fai', reference_fp)):\\n logging.info('preparing reference .fai')\\n tool_args = ('samtools', 'faidx', reference_fp)\\n logging.info(f'executing the following command: {\\\" \\\".join(tool_args)}')\\n subprocess.check_output(tool_args)\\n\\n # create .dict file if doesn't yet exist\\n if not os.path.isfile(re.sub(r'.[^.]*$', '.dict', reference_fp)):\\n logging.info('preparing reference .dict')\\n tool_args = ('picard', 'CreateSequenceDictionary',\\n f'R={reference_fp}',\\n 'O=' + re.sub(r'.[^.]*$', '.dict', reference_fp))\\n logging.info(f'executing the following command: {\\\" \\\".join(tool_args)}')\\n subprocess.check_output(tool_args)\",\n \"def get_reference(self, compare_path):\\n if compare_path:\\n with open(compare_path, 'r') as f:\\n reference = json.load(f)\\n return reference[\\\"boxes\\\"]\\n return None\",\n \"def load(self, file_id):\\n pass\",\n \"def read_reference():\\n global reference\\n reference = cv2.imread(REFERENCE)\\n print(reference)\\n print(reference.shape)\",\n \"def load_lookup_dicto():\\n with open(LOOKUP_PATH, 'rb') as f:\\n lookup_dicto = pickle.load(f)\\n return lookup_dicto\",\n \"def parse_file(path):\\n with open(path, 'rb') as f:\\n content = f.read()\\n\\n # Extract references from the parsed content\\n references = extract_references(content)\\n\\n # Remove references from the parsed content\\n for ref_id in references:\\n content = content.replace(references[ref_id], ' ' * len(references[ref_id]))\\n return content\",\n \"def xref(filename, from_file=None):\\n\\n\\t# First, if the file itself exists, use that file.\\n\\tif os.path.exists(filename):\\n\\t\\treturn filename\\n\\n\\tdirectory, basename = os.path.split(filename)\\n\\n\\tx1 = filename+\\\".xref.txt\\\"\\n\\n\\n\\t# Then look for a file-specific xref\\n\\tif os.path.exists(x1):\\n\\n\\t\\t# Extract the content of the xref file\\n\\t\\twith open(x1, 'r') as f:\\n\\t\\t\\talt_file = f.read()\\n\\n\\t\\t# Direct return of ref file if it is an absolute path and it exists\\n\\t\\tif os.path.isabs(alt_file):\\n\\t\\t\\tif os.path.exists(alt_file):\\n\\t\\t\\t\\treturn alt_file\\n\\t\\t\\telse:\\n\\t\\t\\t\\traise FileNotFoundError(alt_file)\\n\\n\\t\\telse:\\n\\t\\t\\t# it is a relative path\\n\\t\\t\\talt_path = os.path.normpath(os.path.join(directory, alt_file))\\n\\t\\t\\tif from_file:\\n\\t\\t\\t\\treturn xref(alt_path, from_file=x1+\\\"\\\\n from: \\\"+from_file)\\n\\t\\t\\treturn xref(alt_path, from_file=x1)\\n\\n\\tx2d = os.path.join(directory, '_.xref.txt')\\n\\n\\t# Then look for a dir-based xref\\n\\tif os.path.exists(x2d):\\n\\n\\t\\t# Extract the content of the xref file\\n\\t\\twith open(x2d, 'r') as f:\\n\\t\\t\\talt_dir = f.read()\\n\\n\\t\\tx2 = os.path.normpath(os.path.join(directory, alt_dir, basename))\\n\\t\\tif from_file:\\n\\t\\t\\treturn xref(x2, from_file=x2d + \\\"\\\\n from: \\\" + from_file)\\n\\t\\treturn xref(x2, from_file=x2d)\\n\\n\\tif from_file:\\n\\t\\traise FileNotFoundError(filename+\\\"\\\\n from: \\\"+from_file)\\n\\traise FileNotFoundError(filename)\",\n \"def insert_reference(self, reffile):\\n header = self.get_refactor_header(reffile)\\n return self.insert_header_reference(header, os.path.basename(reffile))\",\n \"def _parse_reference_fofn( reference_fofn, target_locus ):\\n log.info(\\\"Parsing reference sequence FOFN\\\")\\n with open( reference_fofn, 'r' ) as handle:\\n for line in handle:\\n filename, locus = line.strip().split()\\n print locus, target_locus\\n if locus == target_locus:\\n return filename\\n msg = 'No fasta file for target locus found!'\\n log.error( msg )\\n raise ValueError( msg )\",\n \"def get_refpaths_from_filename(filename, reference_file_types, observatory=None):\\n from .. import datamodels\\n with datamodels.open(filename) as model:\\n refpaths = get_multiple_reference_paths(model, reference_file_types, observatory)\\n return refpaths\",\n \"def load(self) -> None:\\n doc_ref = self.doc_ref\\n if not isinstance(doc_ref, DocumentReference):\\n return\\n\\n doc = doc_ref.get()\\n if doc.exists:\\n self.load_storage_model(doc.to_dict())\",\n \"def from_file(cls, basename, *args, **keys):\\n log.verbose(\\\"Loading mapping\\\", repr(basename), verbosity=55)\\n path = keys.get(\\\"path\\\", None)\\n if path:\\n filename = os.path.join(path, os.path.basename(basename))\\n basename = filename\\n else:\\n filename = config.locate_mapping(basename)\\n text = utils.get_uri_content(filename)\\n return cls.from_string(text, basename, *args, **keys)\",\n \"def get_reference(self):\\t\\t\\n\\t\\treturn self._reference\",\n \"def get_load_references(self):\\n for path, properties in self.load.items():\\n yield CaseLoadReference(path=path, properties=list(properties))\",\n \"def read_in_translate_vcf(vcf_file, ref_file, compressed=True):\\n from Bio import SeqIO\\n import numpy as np\\n\\n prots = {}\\n\\n posLoc = 0\\n refLoc = 0\\n altLoc = 0\\n sampLoc = 9\\n\\n with open(vcf_file) as f:\\n for line in f:\\n if line[0] != '#':\\n #actual data\\n line = line.strip()\\n dat = line.split('\\\\t')\\n POS = int(dat[posLoc])\\n REF = dat[refLoc]\\n ALT = dat[altLoc].split(',')\\n GEN = dat[0] #'CHROM' or the gene name here\\n calls = np.array(dat[sampLoc:])\\n\\n #get samples that differ from Ref at this site\\n recCalls = {}\\n for sname, sa in zip(samps, calls):\\n if sa != '.':\\n recCalls[sname] = sa\\n\\n #store position and the altLoc\\n for seq, gen in recCalls.iteritems():\\n alt = str(ALT[int(gen[0])-1]) #get the index of the alternate\\n ref = REF\\n pos = POS-1 #VCF numbering starts from 1, but Reference seq numbering\\n #will be from 0 because it's python!\\n gen = GEN #from CHROM, gene name\\n\\n if gen not in prots.keys():\\n prots[gen] = {}\\n prots[gen]['sequences'] = {}\\n prots[gen]['positions'] = []\\n prots[gen]['reference'] = ''\\n if seq not in prots[gen]['sequences'].keys():\\n prots[gen]['sequences'][seq] = {}\\n\\n #will never be insertion or deletion! because translation.\\n prots[gen]['sequences'][seq][pos] = alt\\n prots[gen]['positions'].append(pos)\\n\\n elif line[0] == '#' and line[1] == 'C':\\n #header line, get all the information\\n header = line.strip().split('\\\\t')\\n posLoc = header.index(\\\"POS\\\")\\n refLoc = header.index(\\\"REF\\\")\\n altLoc = header.index(\\\"ALT\\\")\\n sampLoc = header.index(\\\"FORMAT\\\")+1\\n samps = header[sampLoc:]\\n nsamp = len(samps)\\n\\n for refSeq in SeqIO.parse(translation_ref_file(path), format='fasta'):\\n prots[refSeq.name]['reference'] = str(refSeq.seq)\\n posN = np.array(prots[refSeq.name]['positions'])\\n posN = np.unique(posN)\\n prots[refSeq.name]['positions'] = np.sort(posN)\\n\\n return prots\",\n \"def create_reference(filename):\\n contigs = {}\\n with open(filename, \\\"r\\\") as f:\\n header = \\\"\\\"\\n seq = \\\"\\\"\\n for line in f:\\n if line[0] == \\\">\\\":\\n if header:\\n contigs[header] = seq\\n header = line[1:].rstrip()\\n seq = \\\"\\\"\\n else:\\n seq += line.rstrip()\\n\\n return contigs\",\n \"async def parse_ref_obj(self, line):\\n try:\\n val = line.split(b',')[-1].split(b'=')\\n\\n if val[0] == b'ReferenceLatitude':\\n LOG.debug('Ref latitude found...')\\n self.lat = float(val[1])\\n\\n elif val[0] == b'ReferenceLongitude':\\n LOG.debug('Ref longitude found...')\\n self.lon = float(val[1])\\n\\n elif val[0] == b'DataSource':\\n LOG.debug('Ref datasource found...')\\n self.datasource = val[1].decode('UTF-8')\\n\\n elif val[0] == b'Title':\\n LOG.debug('Ref Title found...')\\n self.title = val[1].decode('UTF-8')\\n\\n elif val[0] == b'Author':\\n LOG.debug('Ref Author found...')\\n self.author = val[1].decode('UTF-8')\\n\\n elif val[0] == b'RecordingTime':\\n LOG.debug('Ref time found...')\\n self.start_time = datetime.strptime(val[1].decode('UTF-8'),\\n REF_TIME_FMT)\\n\\n self.all_refs = all(f\\n for f in [self.lat and self.lon and self.start_time])\\n if self.all_refs and not self.written:\\n LOG.info(\\\"All Refs found...writing session data to db...\\\")\\n sess_ser = self.ser()\\n sql = f\\\"\\\"\\\"INSERT into session ({','.join(sess_ser.keys())})\\n VALUES({','.join([\\\"$\\\"+str(i+1) for i, _ in enumerate(sess_ser.keys())])})\\n RETURNING session_id\\n \\\"\\\"\\\"\\n self.session_id = await DB.fetchval(sql, *sess_ser.values())\\n self.written = True\\n LOG.info(\\\"Session session data saved...\\\")\\n except IndexError:\\n pass\",\n \"def load(journal: Journal, file: Path) -> None:\",\n \"def referenzdaten_einlesen(self):\\n self.refdata = np.genfromtxt(self.referencefile, skip_header=1, usecols=np.asarray(self.referenzspalte))\\n self.Referencedata = Reference()\",\n \"def get_refs(genome_build, aligner, config):\\n find_fn = _find_file(config[CONFIG_KEY], startswith=True)\\n ref_prefix = sret.find_ref_prefix(genome_build, find_fn)\\n return sret.standard_genome_refs(genome_build, aligner, ref_prefix, _list(config[CONFIG_KEY]))\",\n \"def load_bib(bib_name):\\n print(\\\"Reading BibTex File: {}\\\".format(bib_name))\\n curdir = osp.abspath('.')\\n bib_path = osp.join(curdir, bib_name)\\n print(\\\"Path: {}\\\".format(bib_path))\\n print('Creating library..')\\n add_dir('library')\\n with open(bib_path, 'r') as f:\\n # txt = f.read()\\n line = f.readline()\\n i = 0\\n start = False\\n while line:\\n i += 1\\n if (line.find('@')==1) or start: # reading entry\\n if start == False:\\n filename = get_name(line)\\n start = True\\n if line.find('title')==1:\\n link = get_link(line)\\n if link is not None:\\n savepath = osp.join(curdir, 'library', filename+'.pdf')\\n save_pdf(link, savepath)\\n if (line.find('}')==1): # end of entry\\n start=False\\n line = f.readline()\\n print(i) # print line number\",\n \"def getReference(self, data: ghidra.program.model.listing.Data, toAddress: ghidra.program.model.address.Address) -> ghidra.program.model.symbol.Reference:\\n ...\",\n \"def load_gene_ontology(self, file_path):\\n\\t\\tpass\",\n \"def Reference(self, default={}):\\n return HEP.ReferenceHEPObject(self.data.get('reference', default))\",\n \"def parseFasta(self, fastaRef):\\n\\n seq = \\\"\\\"\\n prevId = \\\"\\\"\\n with open(fastaRef, 'r') as f:\\n\\n for line in f:\\n if \\\">\\\" == line[0]:\\n # asserting the regex don't fail...\\n found = GENEIDRULE.search(line)\\n if(found):\\n alternate = found.group(1)\\n geneName = found.group(2)\\n self._transcripts[alternate] = geneName\\n else:\\n print(\\\"EnsemblFasta: NOT FOUND\\\")\\n print(line)\\n exit()\\n\\n if(prevId and seq):\\n geneName = self._transcripts[prevId]\\n if geneName in self._genes:\\n gene = self._genes[geneName]\\n else:\\n gene = Gene(geneName)\\n self._genes[geneName] = gene\\n\\n gene.addTranscripts(prevId, seq)\\n seq = \\\"\\\"\\n prevId = alternate\\n else:\\n seq += line.rstrip(\\\"\\\\n\\\")\\n gene.addTranscripts(prevId, seq)\",\n \"def _process_references0(self, references):\\n if \\\"zarr_consolidated_format\\\" in references:\\n # special case for Ike prototype\\n references = _unmodel_hdf5(references)\\n self.references = references\",\n \"def _process_dbxref(self):\\n\\n raw = '/'.join((self.rawdir, 'dbxref'))\\n logger.info(\\\"processing dbxrefs\\\")\\n line_counter = 0\\n\\n with open(raw, 'r') as f:\\n filereader = csv.reader(f, delimiter='\\\\t', quotechar='\\\\\\\"')\\n f.readline() # read the header row; skip\\n for line in filereader:\\n (dbxref_id, db_id, accession, version, description, url) = line\\n # dbxref_id\\tdb_id\\taccession\\tversion\\tdescription\\turl\\n # 1\\t2\\tSO:0000000\\t\\\"\\\"\\n\\n db_ids = { # the databases to fetch\\n 50: 'PMID', # pubmed\\n 68: 'RO', # obo-rel\\n 71: 'FBdv', # FBdv\\n 74: 'FBbt', # FBbt\\n # 28:, # genbank\\n 30: 'OMIM', # MIM\\n # 38, # ncbi\\n 75: 'ISBN', # ISBN\\n 46: 'PMID', # PUBMED\\n 51: 'ISBN', # isbn\\n 52: 'SO', # so\\n # 76, # http\\n 77: 'PMID', # PMID\\n 80: 'FBcv', # FBcv\\n # 95, # MEDLINE\\n 98: 'REACT', # Reactome\\n 103: 'CHEBI', # Chebi\\n 102: 'MESH', # MeSH\\n 106: 'OMIM', # OMIM\\n 105: 'KEGG-path', # KEGG pathway\\n 107: 'DOI', # doi\\n 108: 'CL', # CL\\n 114: 'CHEBI', # CHEBI\\n 115: 'KEGG', # KEGG\\n 116: 'PubChem', # PubChem\\n # 120, # MA???\\n 3: 'GO', # GO\\n 4: 'FlyBase', # FlyBase\\n # 126, # URL\\n 128: 'PATO', # PATO\\n # 131, # IMG\\n 2: 'SO', # SO\\n 136: 'MESH', # MESH\\n 139: 'CARO', # CARO\\n 140: 'NCBITaxon', # NCBITaxon\\n # 151, # MP ???\\n 161: 'DOI', # doi\\n 36: 'BDGP', # BDGP\\n # 55, # DGRC\\n # 54, # DRSC\\n # 169, # Transgenic RNAi project???\\n 231: 'RO', # RO ???\\n 180: 'NCBIGene', # entrezgene\\n # 192, # Bloomington stock center\\n 197: 'UBERON', # Uberon\\n 212: 'ENSEMBL', # Ensembl\\n # 129, # GenomeRNAi\\n 275: 'PMID', # PubMed\\n 286: 'PMID', # pmid\\n 264: 'HGNC',\\n # 265: 'OMIM', # OMIM_Gene\\n 266: 'OMIM', # OMIM_Phenotype\\n 300: 'DOID', # DOID\\n 302: 'MESH', # MSH\\n 347: 'PMID', # Pubmed\\n }\\n\\n if accession.strip() != '' and int(db_id) in db_ids:\\n # scrub some identifiers here\\n m = re.match(\\n r'(doi|SO|GO|FBcv|FBbt_root|FBdv|FBgn|FBdv_root|FlyBase|FBbt):',\\n accession)\\n if m:\\n accession = re.sub(m.group(1)+r'\\\\:', '', accession)\\n elif re.match(\\n r'(FlyBase miscellaneous CV|cell_lineprop|relationship type|FBgn$)',\\n accession):\\n continue\\n elif re.match(r'\\\\:', accession): # starts with a colon\\n accession = re.sub(r'\\\\:', '', accession)\\n elif re.search(r'\\\\s', accession):\\n # skip anything with a space\\n # logger.debug(\\n # 'dbxref %s accession has a space: %s',\\n # dbxref_id, accession)\\n continue\\n\\n if re.match(r'http', accession):\\n did = accession.strip()\\n else:\\n prefix = db_ids.get(int(db_id))\\n did = ':'.join((prefix, accession.strip()))\\n if re.search(r'\\\\:', accession) and prefix != 'DOI':\\n logger.warning(\\n 'id %s may be malformed; skipping', did)\\n\\n self.dbxrefs[dbxref_id] = {db_id: did}\\n\\n elif url != '':\\n self.dbxrefs[dbxref_id] = {db_id: url.strip()}\\n else:\\n continue\\n\\n # the following are some special cases that we scrub\\n if int(db_id) == 2 \\\\\\n and accession.strip() == 'transgenic_transposon':\\n # transgenic_transposable_element\\n self.dbxrefs[dbxref_id] = {db_id: 'SO:0000796'}\\n\\n line_counter += 1\\n\\n return\",\n \"def open_ref(self, ref, accept_string=False, make_sweetheart=False):\\n ref = self.task_record.retrieve_ref(ref)\\n if not accept_string: \\n ctx = retrieve_filename_for_ref(ref, self.task_record, return_ctx=True)\\n else:\\n ctx = retrieve_file_or_string_for_ref(ref, self.task_record)\\n if ctx.completed_ref is not None:\\n if make_sweetheart:\\n ctx.completed_ref = SW2_SweetheartReference.from_concrete(ctx.completed_ref, get_own_netloc())\\n self.task_record.publish_ref(ctx.completed_ref)\\n return ctx.to_safe_dict()\",\n \"def _import(file_path):\\n proxy_factory.import_proxies(open(file_path, 'r'))\",\n \"def read_content_load(self, filename):\\n str_file_woc = self.import_file(filename)\\n self.parse_load(str_file_woc)\\n self.disp_load_info()\",\n \"def read_reference_data():\\n return {f:read_local_file(f) for f in os.listdir(DATA_DIR)}\",\n \"def populateReference(self, reference_data_folder=None):\\n if reference_data_folder is None:\\n reference_data_folder = os.path.join(\\\"..\\\", \\\"default_data\\\")\\n\\n files = os.listdir(reference_data_folder)\\n\\n reference_tables = []\\n # Create reference table list\\n with self.session_scope() as session:\\n self.setupTabletypeMap()\\n reference_table_objects = self.metaClasses[TableTypes.REFERENCE]\\n for object in list(reference_table_objects):\\n reference_tables.append(object.__tablename__)\\n\\n reference_files = [file for file in files if os.path.splitext(file)[0] in reference_tables]\\n for file in reference_files:\\n # split file into filename and extension\\n table_name, _ = os.path.splitext(file)\\n possible_method = 'addTo' + table_name\\n method_to_call = getattr(self, possible_method, None)\\n if method_to_call:\\n with open(os.path.join(reference_data_folder, file), 'r') as f:\\n reader = csv.reader(f)\\n # skip header\\n _ = next(reader)\\n with self.session_scope() as session:\\n for row in reader:\\n # this solves error of add functions which take one\\n # value instead of list of strings\\n if len(row) == 1:\\n method_to_call(row[0])\\n else:\\n method_to_call(*row)\\n else:\\n print(f\\\"Method({possible_method}) not found!\\\")\",\n \"def from_path(cls, ref_full_path, **kwargs):\\n try:\\n with open(ref_full_path) as fp:\\n obj = yaml.load(fp, Loader=YamlLoader)\\n _kwargs = {key: value for key, value in obj.items() if key not in ('data', 'from_base64')}\\n kwargs.update(_kwargs)\\n return cls(obj['data'], from_base64=True, **kwargs)\\n\\n except IOError as ex:\\n if ex.errno == errno.ENOENT:\\n return None\",\n \"def add_references_to_papers(infile, dir):\\n papers = json.load(open(infile))\\n for paper in papers:\\n for file in os.listdir(dir):\\n if file.split(\\\".txt\\\")[0] == paper['doi']: # Must find the correct file to parse\\n filename = TEXT_DIR+file\\n refs =extract_references_from_txt(filename) #Uses the text files to find references\\n paper['references']=refs\\n return papers\",\n \"def get_actual_ref(self, ref):\\n while ref in self.reference_map:\\n ref = self.reference_map[ref]\\n return ref\",\n \"def create_reference(\\n self, response_checker=default_checker.default_journey_checker\\n ):\\n # Check that the file doesn't already exist\\n filename = self.get_file_name()\\n filepath = os.path.join(config[\\\"REFERENCE_FILE_PATH\\\"], filename)\\n\\n if os.path.isfile(filepath):\\n logger.warning(\\n \\\"NO REF FILE CREATED - {} is already present\\\".format(filepath)\\n )\\n else:\\n # Concatenate reference file info\\n reference_text = OrderedDict()\\n reference_text[\\\"query\\\"] = self.query.replace(\\n config[\\\"URL_JORMUN\\\"][7:], \\\"localhost\\\"\\n )\\n logger.warning(\\\"Query: {}\\\".format(self.query))\\n reference_text[\\\"response\\\"] = response_checker.filter(\\n json.loads(self.full_resp)\\n )\\n reference_text[\\\"full_response\\\"] = json.loads(\\n self.full_resp.replace(config[\\\"URL_JORMUN\\\"][7:], \\\"localhost\\\")\\n )\\n\\n # Write reference file directly in the references folder\\n with open(filepath, \\\"w\\\") as ref:\\n ref.write(json.dumps(reference_text, indent=4))\\n logger.info(\\\"Created reference file : {}\\\".format(filepath))\",\n \"def fetchReferences(self, dataRef, exposure):\\n skyMap = dataRef.get(self.dataPrefix + \\\"skyMap\\\", immediate=True)\\n tractInfo = skyMap[dataRef.dataId[\\\"tract\\\"]]\\n patch = tuple(int(v) for v in dataRef.dataId[\\\"patch\\\"].split(\\\",\\\"))\\n patchInfo = tractInfo.getPatchInfo(patch)\\n references = lsst.afw.table.SourceCatalog(self.references.schema)\\n references.extend(self.references.fetchInPatches(dataRef, patchList=[patchInfo]))\\n return references\",\n \"def extract_references(content):\\n references = {}\\n content = content.replace(\\\"\\\\n\\\", \\\"\\\\\\\\n\\\")\\n matches = re.findall('(\\\\[[0-9]+\\\\][^\\\\[]*?(?=\\\\[|Acknowledge|Fig|Table|Conclusion|pdf))', content)\\n if matches:\\n for match in matches:\\n ref_id = get_reference_id(match)\\n # No reference id exist -- skip it\\n if ref_id != -1:\\n value = match.replace('\\\\\\\\n', '\\\\n')\\n references[ref_id] = value\\n return references\",\n \"def test_load_ref_mask():\\n\\n itraj = os.path.join(path, \\\"alanine_dipeptide.nc\\\")\\n iref = os.path.join(path, \\\"alanine_dipeptide.ncrst\\\")\\n itop = os.path.join(path, \\\"alanine_dipeptide.parm7\\\")\\n\\n for mask in [\\\":ALA,ACE,NME\\\", \\\"!:WAT\\\"]:\\n traj = tools.load_traj(itraj, itop, mask)\\n\\n with pytest.raises(ValueError):\\n ref = tools.load_ref(itraj, itop, mask)\\n\\n ref = tools.load_ref(iref, itop, mask)\\n\\n assert ref.n_frames == 1\\n assert ref.n_atoms == 22\",\n \"def read_file(path):\\n # Mystery arguments:\\n strictness = False\\n # Read the string:\\n return _iterate_bibtexsource(_bibtex.open_file(path, strictness))\",\n \"def load_knowledge(net, filepath):\\n\\treloaded = loadz(filepath)\\n\\tknowledge = [(name, reloaded[name]) for name in sorted(reloaded.keys())]\\n\\tset_knowledge(net, knowledge)\",\n \"def add_file_ref(self, file_name: str) -> None:\\n self.referenced_in.add(file_name)\",\n \"def get_reference_list(reference_sequences_path):\\n\\n\\ttry:\\n\\t\\tinfile = open(reference_sequences_path, \\\"rU\\\")\\n\\t\\tsequences = infile.read()\\n\\t\\treference_sequences = sequences.splitlines()\\n\\t\\tinfile.close()\\n\\t\\treturn reference_sequences\\n\\texcept IOError as e:\\n\\t\\tprint(str(e))\\n\\t\\tsys.exit(1) # Aborts program. (exit(1) indicates that an error occurred)\",\n \"def load_fileaccess(cls, trial_ref, session=None):\\n session = session or relational.session\\n result = session.query(cls.m).filter(cls.m.trial_id == trial_ref)\\n return result.first()\",\n \"def __init__(self, file_path):\\n self.file_path = file_path\\n try:\\n self.FastaFile = pysam.FastaFile(self.file_path)\\n except:\\n raise IOError(\\\"REFERENCE FILE ERROR\\\")\",\n \"def get_Tref(self,typ,file_number):\\n if typ == 'emis':\\n return self.beam_emis[file_number].T_ref\\n elif typ == 'atte':\\n return self.beam_atte[file_number].T_ref\\n else:\\n raise NameError('No list with this name: {0}'.format(typ))\",\n \"def open_ref(self, ref):\\n ref = self.task_record.retrieve_ref(ref)\\n return self.block_store.retrieve_filename_for_ref(ref)\",\n \"def get_reference_datetime(file):\\n date_string = file.root.discharge1._f_getAttr('reference_datetime')[0]\\n ref_date = datetime.datetime.strptime(date_string, '%d-%b-%Y;%H:%M:%S.%f')\\n\\n return ref_date\",\n \"def fetch_genome(reference_name):\\n from utils import script_dir\\n genome_list = yaml.load(open(script_dir + \\\"/utils/genomes.yaml\\\",\\\"r\\\"))\\n makedir(\\\"genomes\\\")\\n if reference_name not in genome_list:\\n msg(\\\"Reference Genome not available\\\", \\\"error\\\")\\n ftp_loc = genome_list[reference_name]\\n filename = os.path.split(ftp_loc)[1]\\n makedir(\\\"{script_dir}/genomes/{reference_name}\\\".format(**locals()))\\n reference_loc = \\\"{script_dir}/genomes/{reference_name}/{filename}\\\".format(**locals())\\n if not file_exists( reference_loc + \\\".sa\\\"):\\n print(\\\"Downloading {filename}\\\".format(**locals()))\\n os.system(\\\"curl {ftp_loc} > {script_dir}/genomes/{reference_name}/{filename}\\\".format(**locals()))\\n # Unzip and rezip with bgzip\\n if filename.endswith(\\\".gz\\\"):\\n os.system(\\\"gunzip {reference_loc} && bgzip {reference_loc2}\\\".format(reference_loc=reference_loc, reference_loc2=reference_loc.replace(\\\".gz\\\",\\\"\\\")))\\n print(\\\"Indexing {script_dir}/genomes/{reference_name}/{filename}\\\".format(**locals()))\\n os.system(\\\"bwa index {script_dir}/genomes/{reference_name}/{filename}\\\".format(**locals()))\\n else:\\n msg(\\\"Reference Already downloaded and indexed.\\\", \\\"error\\\")\",\n \"def load_replace_candidate(self, filename=None, config=None):\\n raise NotImplementedError\",\n \"def make_reference(reference_path, reference_meta, model):\\n # Make file dirs\\n reference_dirs = list(reference_meta.keys())\\n ids = []\\n \\n # Get file fullpath\\n files = []\\n import glob\\n if DEBUG:\\n for refdir in reference_dirs[:20]:\\n foundfiles = glob.glob(os.path.join(reference_path, refdir, \\\"*jpg\\\"))\\n files.extend(foundfiles)\\n for _ in foundfiles:\\n ids.append(refdir)\\n else:\\n for refdir in reference_dirs:\\n foundfiles = glob.glob(os.path.join(reference_path, refdir, \\\"*jpg\\\"))\\n files.extend(foundfiles)\\n for _ in foundfiles:\\n ids.append(refdir)\\n dataset = buzaiDataset(files, transforms_val)\\n loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, sampler=SequentialSampler(dataset), num_workers=num_workers)\\n\\n # Get embeddings\\n embeddings = predict(loader, files, model)\\n \\n return embeddings, np.array(ids)\",\n \"def ProcessEntryFile(fd):\\n\\tglobal reference\\n\\n\\tname = ''\\n\\tfilename = ''\\n\\tdd = {}\\n\\teof = False\\n\\twhile not eof:\\n\\t\\tline = fd.readline()\\n\\t\\tif len(line) == 0:\\n\\t\\t\\teof = True\\n\\t\\t\\tif name in reference.keys():\\n\\t\\t\\t\\treference[name] = dd\\n\\t\\t\\telif name != '':\\n\\t\\t\\t\\treference[name] = dd\\n\\t\\t\\t#if verbose: print reference\\n\\t\\telse:\\n\\t\\t\\tline = line.strip()\\n\\t\\t\\tif line.startswith('name'):\\n\\t\\t\\t\\tif name in reference.keys() or name != '':\\n\\t\\t\\t\\t\\treference[name] = dd\\n\\t\\t\\t\\ttokens = line.split()\\n\\t\\t\\t\\tnn = tokens[0].split('=')\\n\\t\\t\\t\\tname = nn[1]\\n\\t\\t\\t\\tdd = {}\\n\\t\\t\\telif line.startswith('file'):\\n\\t\\t\\t\\tfilename = line[len('file='):]\\n\\t\\t\\t\\tif name in reference.keys():\\n\\t\\t\\t\\t\\tdd \\t= reference[name]\\n\\t\\t\\t\\t\\tif dd.has_key(filename):\\n\\t\\t\\t\\t\\t\\tfilename = ''\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif filename != '':\\n\\t\\t\\t\\t\\ttokens = line.split()\\n\\t\\t\\t\\t\\tlength = len(tokens)\\n\\t\\t\\t\\t\\t#print tokens\\n\\t\\t\\t\\t\\tfirst = True\\n\\t\\t\\t\\t\\tfor t in range(0,length,2):\\n\\t\\t\\t\\t\\t\\tpos = tokens[t].find('=')\\n\\t\\t\\t\\t\\t\\tcountline = int(tokens[t][pos+1:])\\n\\t\\t\\t\\t\\t\\tpos = tokens[t+1].find('=')\\n\\t\\t\\t\\t\\t\\tref = tokens[t+1][pos+1:]\\n\\t\\t\\t\\t\\t\\ttline = (countline,ref)\\n\\t\\t\\t\\t\\t\\tif first:\\n\\t\\t\\t\\t\\t\\t\\tdd[filename] = [tline]\\n\\t\\t\\t\\t\\t\\t\\tfirst = False\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tff = dd[filename] #list of tuples (line,ref)\\t\\t\\t\\t\\n\\t\\t\\t\\t\\t\\t\\tff.append(tline)\\n\\t\\t\\t\\t\\t\\t\\tdd[filename] = ff\",\n \"def unwrap(xml_file, missing_message=\\\"NO TRANSLATION AVAILABLE\\\"):\\n tree = ET.parse(xml_file) \\n\\n # Find and check the source langs, ref langs and translators\\n src_langs, ref_langs, translators = set(), set(), set()\\n\\n for src_doc in tree.getroot().findall(\\\".//src\\\"):\\n src_langs.add(src_doc.get(\\\"lang\\\"))\\n\\n for ref_doc in tree.getroot().findall(\\\".//ref\\\"):\\n ref_langs.add(ref_doc.get(\\\"lang\\\"))\\n translator = ref_doc.get(\\\"translator\\\")\\n if translator: translators.add(translator)\\n \\n if len(src_langs) > 1:\\n raise RuntimeError(\\\"Multiple source languages found\\\")\\n\\n if len(src_langs) == 0:\\n raise RuntimeError(\\\"No source languages found\\\")\\n\\n src_lang = src_langs.pop()\\n src = []\\n\\n if len(ref_langs) > 1:\\n raise RuntimeError(\\\"Multiple reference languages found -- this case is not currently handled\\\")\\n\\n\\n if len(ref_langs) > 0:\\n if len(translators) == 0:\\n LOG.info(\\\"No translator identifiers found -- reading first translation for each document\\\")\\n translators.add(DEFAULT_TRANSLATOR)\\n ref_lang = ref_langs.pop()\\n ref = {translator : [] for translator in translators}\\n else:\\n LOG.info(\\\"No references found\\\")\\n ref_lang = None\\n ref = {}\\n\\n\\n # Extract text\\n src_sent_count,doc_count = 0,0\\n for doc in tree.getroot().findall(\\\".//doc\\\"):\\n doc_count += 1\\n src_sents = {int(seg.get(\\\"id\\\")): seg.text for seg in doc.findall(\\\".//src//seg\\\")}\\n if ref_lang: \\n ref_docs = doc.findall(\\\".//ref\\\")\\n trans_to_ref = {}\\n\\n # If no translator identifiers, we just read one reference (if any) \\n # If there are translator identifiers, we add a reference for each translator\\n\\n def get_ref_sents(ref_doc):\\n return {int(seg.get(\\\"id\\\")): seg.text for seg in ref_doc.findall(f\\\".//seg\\\")}\\n\\n if len(translators) == 1 and DEFAULT_TRANSLATOR in translators:\\n if len(ref_docs):\\n trans_to_ref[DEFAULT_TRANSLATOR] = get_ref_sents(ref_docs[0])\\n else:\\n trans_to_ref[DEFAULT_TRANSLATOR] = {}\\n else:\\n trans_to_ref = {ref_doc.get(\\\"translator\\\"): get_ref_sents(ref_doc) for ref_doc in ref_docs}\\n\\n for seg_id in sorted(src_sents.keys()):\\n src.append(src_sents[seg_id])\\n src_sent_count += 1\\n if ref_lang:\\n for translator in translators:\\n ref[translator].append(trans_to_ref.get(translator, {translator: {}}).get(seg_id, missing_message))\\n\\n LOG.info(f\\\"Extracted {doc_count} document(s) containing {src_sent_count} sentences in {src_lang}\\\")\\n\\n\\n return src_lang,src,ref_lang,ref\",\n \"def load(self, filename):\\n raise NotImplementedError\",\n \"def read_in_file(self, file):\\n with open(self.file) as doc:\\n trie = dict()\\n for line in doc:\\n line = line.split(' ')[0]\\n self.make_trie(trie, line.rstrip())\\n return trie\",\n \"def load(self):\\r\\n self.read(self.filename)\",\n \"def __init__(self, url):\\n\\n lines = [l.strip().split() for l in open(url)]\\n\\n # Split the lines and the headers\\n i = 0\\n self.refs = {} # name: [len, offset-to-first-record, offset-to-last-record + 1]\\n\\n while(lines[i][0][0] == '@'):\\n line = lines[i]\\n if line[0] == '@SQ':\\n sn = line[1].split(':')[1]\\n ln = int(line[2].split(':')[1])\\n self.refs[sn] = [ln, None, None]\\n i += 1\\n\\n # Process the mapped reads\\n # - create offset pointers to the start of each chromosome\\n # - convert the position to an int\\n cur_chr = lines[i][2]\\n self.refs[cur_chr][1] = i\\n \\n while(i < len(lines)):\\n if not (int(lines[i][1]) & 0x4): \\n lines[i][3] = int(lines[i][3])\\n\\n if lines[i][2] != cur_chr:\\n self.refs[cur_chr][2] = i # mark the end\\n cur_chr = lines[i][2] \\n self.refs[cur_chr][1] = i # mark the start\\n i += 1\\n\\n self.lines = lines\\n \\n return\",\n \"def read_from_file(self, filename: str) -> None:\",\n \"def load(filepath: str) -> Torrent:\\n # open .torrent file for binary reading\\n with open(filepath, 'rb') as f:\\n content = f.read()\\n\\n # decode the B-encoded content\\n meta_info = decoder.decode(content)\\n \\n # create Torrent object\\n t = Torrent(meta_info)\\n return t\",\n \"def load_lookup_table(path):\\n assert os.path.exists(path), \\\"Lookup table file not found.\\\"\\n with open(path, \\\"rb\\\") as dillfile:\\n return dill.load(dillfile)\",\n \"def __loadFromFile(self):\\n try:\\n f=open(self.__fileR, \\\"r\\\")\\n line =f.readline().strip()\\n rez=[]\\n while line!=\\\"\\\":\\n attrs=line.split(\\\",\\\")\\n rt=Rent(attrs[0], attrs[1], attrs[2], attrs[3])\\n rez.append(rt)\\n line=f.readline().strip()\\n f.close()\\n return rez\\n #the file cannot be reached\\n except IOError:\\n return None\",\n \"def load(filename):\\r\\n wholeTract= nib.streamlines.load(filename) \\r\\n wholeTract = wholeTract.streamlines\\r\\n return wholeTract\",\n \"async def load(self, file: IO) -> dict:\",\n \"def load(filename):\\n o = open(filename)\\n s = o.read()\\n a = ArffFile.parse(s)\\n o.close()\\n return a\",\n \"def scan_line(line):\\n URL = None\\n type = None\\n # Check for direct URL first\\n match = re.search(MATCH_URL, line)\\n if match:\\n return match.group(0)\\n # Check for reference URL \\n match = re.match(MATCH_REF_URL, line)\\n if not match:\\n return None\\n # So, it's a reference, scan doc for corresponding URL\\n return expand_reference(match.group(1))\",\n \"def _dereference(self, ref_url, obj_path, recursions):\\n # In order to start dereferencing anything in the referenced URL, we have\\n # to read and parse it, of course.\\n contents = _url.fetch_url(ref_url, self.__reference_cache, self.__encoding)\\n\\n # In this inner parser's specification, we can now look for the referenced\\n # object.\\n value = contents\\n if len(obj_path) != 0:\\n from prance.util.path import path_get\\n try:\\n value = path_get(value, obj_path)\\n except (KeyError, IndexError, TypeError) as ex:\\n raise _url.ResolutionError('Cannot resolve reference \\\"%s\\\": %s'\\n % (ref_url.geturl(), str(ex)))\\n\\n # Deep copy value; we don't want to create recursive structures\\n import copy\\n value = copy.deepcopy(value)\\n\\n # Now resolve partial specs\\n value = self._resolve_partial(ref_url, value, recursions)\\n\\n # That's it!\\n return value\",\n \"def import_gff(file, genome_version, verbose = False):\\n \\n from tridentdb import models\\n import re\\n from django.db.utils import DatabaseError\\n \\n if genome_version == None:\\n print(\\\"Genome Version is needed for loading a gff file.\\\")\\n return\\n\\n genomes = models.Genome.objects.filter(genome_ver = genome_version)\\n if len(genomes) == 0:\\n print(\\\"Unknown Genome Version: %s\\\" % genome_version)\\n return\\n \\n lineno = 1\\n for line in file:\\n if verbose:\\n print(\\\"Line Number: %d\\\" % lineno)\\n lineno += 1\\n if not line:\\n continue\\n line = line.strip()\\n if line[0] == '#':\\n continue\\n info = line.split('\\\\t')\\n chromosome = info[0].replace(\\\"chr\\\", \\\"\\\")\\n is_primary_transcript = (info[2] == 'miRNA_primary_transcript')\\n genomic_mir_start = info[3]\\n genomic_mir_end = info[4]\\n is_on_positive_strand = (info[6] == '+')\\n \\n mirbase_id = mirbase_acc = mirbase_name = mirbase_derives_from = None\\n mirbase = info[8].split(';')\\n for tag in mirbase:\\n (name, val) = tag.split('=')\\n if name == \\\"ID\\\":\\n mirbase_id = val\\n elif name == \\\"accession_number\\\":\\n mirbase_acc = val\\n elif name == \\\"Alias\\\":\\n # Use alias for accession_number IFF accession_number\\n # is not used\\n if not mirbase_acc:\\n mirbase_acc = val\\n elif name == \\\"Name\\\":\\n mirbase_name = val\\n elif name == \\\"derives_from\\\":\\n mirbase_derives_from = val\\n else:\\n print(\\\"Unknown Mirbase tag: \\\\\\\"%s\\\\\\\"\\\" % name)\\n continue\\n\\n mirna = models.MicroRNA(chromosome=chromosome, is_primary_transcript = is_primary_transcript, genomic_mir_start = genomic_mir_start, genomic_mir_end = genomic_mir_end, is_on_positive_strand = is_on_positive_strand, mirbase_id = mirbase_id, mirbase_acc = mirbase_acc, mirbase_name = mirbase_name, mirbase_derives_from = mirbase_derives_from, genome = genomes[0] )\\n \\n try:\\n mirna.save()\\n except DatabaseError as de:\\n from sys import stderr\\n stderr.write(\\\"Error loading GFF line: {0}\\\\n\\\".format(line))\\n raise de\\n ##end of import_gff\",\n \"def read_relations(db, openfile):\\n pass\",\n \"def load(self, filepath):\\n _ = filepath\\n return self\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65891796","0.63777584","0.6298703","0.6292496","0.6262168","0.60937804","0.605416","0.5891338","0.5869947","0.58570164","0.5797035","0.5793951","0.57778513","0.57709974","0.57157594","0.56981564","0.56818175","0.56198025","0.56030697","0.5597448","0.5589372","0.5550355","0.5540199","0.5536473","0.55224794","0.5491346","0.5463888","0.5459584","0.5448394","0.5447987","0.544246","0.5440234","0.5438802","0.5436728","0.5427024","0.54089797","0.53779286","0.5375321","0.5334508","0.5327387","0.5322714","0.52853227","0.5272417","0.5272357","0.5258437","0.52498686","0.52470505","0.52346337","0.5228756","0.5227995","0.5227282","0.5194258","0.51814044","0.51734966","0.5166571","0.5160635","0.515957","0.51530814","0.51435477","0.5142717","0.5141595","0.51406056","0.51348615","0.5130156","0.5127694","0.512737","0.51185334","0.5104571","0.5103668","0.5085788","0.50665784","0.50573534","0.5050247","0.5050167","0.50490236","0.5041171","0.5039574","0.50355387","0.5025786","0.5021058","0.5018985","0.5015341","0.50133157","0.50123566","0.5006321","0.50042087","0.5001959","0.49870992","0.49685314","0.4968201","0.4965631","0.49640194","0.49620557","0.4951804","0.49475887","0.49471444","0.49440223","0.49369508","0.4933529","0.49327853"],"string":"[\n \"0.65891796\",\n \"0.63777584\",\n \"0.6298703\",\n \"0.6292496\",\n \"0.6262168\",\n \"0.60937804\",\n \"0.605416\",\n \"0.5891338\",\n \"0.5869947\",\n \"0.58570164\",\n \"0.5797035\",\n \"0.5793951\",\n \"0.57778513\",\n \"0.57709974\",\n \"0.57157594\",\n \"0.56981564\",\n \"0.56818175\",\n \"0.56198025\",\n \"0.56030697\",\n \"0.5597448\",\n \"0.5589372\",\n \"0.5550355\",\n \"0.5540199\",\n \"0.5536473\",\n \"0.55224794\",\n \"0.5491346\",\n \"0.5463888\",\n \"0.5459584\",\n \"0.5448394\",\n \"0.5447987\",\n \"0.544246\",\n \"0.5440234\",\n \"0.5438802\",\n \"0.5436728\",\n \"0.5427024\",\n \"0.54089797\",\n \"0.53779286\",\n \"0.5375321\",\n \"0.5334508\",\n \"0.5327387\",\n \"0.5322714\",\n \"0.52853227\",\n \"0.5272417\",\n \"0.5272357\",\n \"0.5258437\",\n \"0.52498686\",\n \"0.52470505\",\n \"0.52346337\",\n \"0.5228756\",\n \"0.5227995\",\n \"0.5227282\",\n \"0.5194258\",\n \"0.51814044\",\n \"0.51734966\",\n \"0.5166571\",\n \"0.5160635\",\n \"0.515957\",\n \"0.51530814\",\n \"0.51435477\",\n \"0.5142717\",\n \"0.5141595\",\n \"0.51406056\",\n \"0.51348615\",\n \"0.5130156\",\n \"0.5127694\",\n \"0.512737\",\n \"0.51185334\",\n \"0.5104571\",\n \"0.5103668\",\n \"0.5085788\",\n \"0.50665784\",\n \"0.50573534\",\n \"0.5050247\",\n \"0.5050167\",\n \"0.50490236\",\n \"0.5041171\",\n \"0.5039574\",\n \"0.50355387\",\n \"0.5025786\",\n \"0.5021058\",\n \"0.5018985\",\n \"0.5015341\",\n \"0.50133157\",\n \"0.50123566\",\n \"0.5006321\",\n \"0.50042087\",\n \"0.5001959\",\n \"0.49870992\",\n \"0.49685314\",\n \"0.4968201\",\n \"0.4965631\",\n \"0.49640194\",\n \"0.49620557\",\n \"0.4951804\",\n \"0.49475887\",\n \"0.49471444\",\n \"0.49440223\",\n \"0.49369508\",\n \"0.4933529\",\n \"0.49327853\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6084144"},"document_rank":{"kind":"string","value":"6"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":231,"numItemsPerPage":100,"numTotalItems":95772,"offset":23100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjcwMzI1OSwianRpIjoiZjFmNTExZmMtNzNiYS00M2FkLWE0MWEtYzM0MTI4ZmIzZDA4Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY3MDY4NTksImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.ei0qa0eFTQSlLUyXbKBjeq9jnLvGRlHsdTss9ic0Gvt9xQ3UOOD7DJ5UqJ01xuCE2SdgKHpibrE1AZFqqSOBDw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Parse an input specs into a jax.ShapeDtypeStruct. | def input_spec_to_jax_shape_dtype_struct(
spec: Union[Tuple[Tuple[int, ...], jnp.dtype], Tuple[int, ...]],
batch_size: Optional[int] = None) -> jax.ShapeDtypeStruct:
spec = tuple(spec)
if len(spec) == 2 and isinstance(spec[0], collections.abc.Iterable):
shape = (batch_size,) + tuple(spec[0][1:]) if batc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_spec (spec_file):\n spec_object = None\n spec_name = spec_file.replace(\".\", \"_\")\n params = []\n default_params = {}\n int_conversion = []\n namedtuple = False\n delimiter = \"\\n\"\n\n spec_file = open(spec_file, \"r\")\n spec = spec_file.readlines()\n spec_file.close()... | [
"0.53998345",
"0.5399715",
"0.53511655",
"0.52155787",
"0.5175422",
"0.50308526",
"0.4997735",
"0.4945539",
"0.48813435",
"0.48683077",
"0.4854738",
"0.485412",
"0.4849468",
"0.48474205",
"0.4809551",
"0.47939855",
"0.4788989",
"0.47868943",
"0.47620076",
"0.4761896",
"0.4733... | 0.6715354 | 0 |
Performs static analysis of the graph to compute theoretical FLOPs. One can also use the XProf profiler to get the actual FLOPs at runtime based on device counters. Theoretical FLOPs are more useful for comparing models across different library implementations and is hardwareagnostic. | def compute_flops(flax_model_apply_fn: Callable[[jnp.ndarray], Any],
input_spec: Sequence[Union[Tuple[Tuple[int, ...], jnp.dtype],
Tuple[int, ...], None]],
fuse_multiply_add: bool) -> float:
dummy_input = []
for spec in input_spec:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def computeFScores(self, targetLabels, actualLabels):\r\n if self.prMeasures is None:\r\n self.prMeasures = self.computePRMeasures(targetLabels, actualLabels)\r\n if self.prMeasures[0] == 0:\r\n return 0\r\n self.f1score = 2 * self.prMeasures[0] * self.prMeasures[... | [
"0.5671943",
"0.566783",
"0.5635351",
"0.5540157",
"0.54438156",
"0.53901833",
"0.5383728",
"0.5367138",
"0.53378254",
"0.53330487",
"0.5325549",
"0.5321701",
"0.5314026",
"0.5289707",
"0.5265528",
"0.52629256",
"0.52588695",
"0.5254436",
"0.5246063",
"0.5239378",
"0.52301675... | 0.5317833 | 12 |
Load dataset from file '../data/dataset.txt' and transfer to a list. | def load_data():
with open('../data/dataset.txt', 'r') as data_file:
return data_file.read().split('\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_datasets(filepath):\n\n data_file = open(filepath, 'r')\n data_list = data_file.readlines()\n data_file.close()\n\n return data_list",
"def load_data(path_dataset):\n data = read_txt(path_dataset)[1:]\n return preprocess_data(data)",
"def load_data(text_file) -> list:\n\n file = o... | [
"0.7310075",
"0.7081436",
"0.69368184",
"0.6830235",
"0.681044",
"0.6765116",
"0.6706157",
"0.6666456",
"0.6652845",
"0.6651481",
"0.664702",
"0.6612349",
"0.660296",
"0.65759784",
"0.6559554",
"0.65574807",
"0.65524375",
"0.6543727",
"0.6543159",
"0.6526245",
"0.651906",
"... | 0.8187677 | 0 |
Load stop words from file '../data/stop_words.txt' and transfer to a list. | def load_stop_words():
with open('../data/stop_words.txt', 'r') as stop_words_file:
return stop_words_file.read().split() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_stop_words() -> list:\r\n with open(f'{ENGINE}/stop_words.txt', 'r') as i:\r\n stop_words = i.read().splitlines()\r\n stop_words = list(map(lambda x: x.upper(), stop_words)) # Force all stop words to UPPER case.\r\n return stop_words",
"def load_stop_list():\n stop_list = []\n ... | [
"0.86854786",
"0.85702604",
"0.82870823",
"0.8085797",
"0.8026547",
"0.80048776",
"0.7859866",
"0.7739571",
"0.75412995",
"0.75381225",
"0.7501206",
"0.74701536",
"0.7468609",
"0.7460182",
"0.7407307",
"0.7407307",
"0.7407307",
"0.7394937",
"0.7389229",
"0.7364115",
"0.734005... | 0.8828992 | 0 |
Generate a label list according to the first word in each line of dataset. | def generate_labels():
label_set = set([])
for data in load_data():
label = data.split(' ', 1)[0]
label_set.add(label)
labels = list(label_set)
labels.sort()
return labels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data_labels(datasets):\n # Split by words\n x_text = datasets['data']\n x_text = [clean_str(sent) for sent in x_text]\n # Generate labels\n labels = [0, 1, 2, 3, 4]\n print(len(x_text))\n for i in range(len(x_text)):\n label = [0 for j in datasets['target_names']] \n ... | [
"0.67625064",
"0.67520624",
"0.67273957",
"0.6714275",
"0.6602932",
"0.64764017",
"0.6445512",
"0.6442318",
"0.64260095",
"0.64215446",
"0.6377378",
"0.63764703",
"0.63636106",
"0.62697333",
"0.6204013",
"0.6184638",
"0.616843",
"0.6156621",
"0.6108328",
"0.6107273",
"0.60736... | 0.7592209 | 0 |
Write labels to file '../data/labels.txt', each line is a label | def write_labels():
with open('../data/labels.txt', 'w') as labels_file:
labels = generate_labels()
labels_file.write('\n'.join(labels)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _write_labels(self, labels: List[str], labels_path: Path):\n labels_path.write_text(escape_line_delimited_texts(labels))",
"def _write_labels(self, labels: List[str], labels_path: Path):\n labels_path.write_text(escape_line_delimited_texts(labels))",
"def SaveLabels(filepath, labels):\n # ... | [
"0.8117613",
"0.8117613",
"0.7926602",
"0.78796244",
"0.77901435",
"0.7717908",
"0.75571084",
"0.73993284",
"0.7089501",
"0.70833546",
"0.70000726",
"0.6994793",
"0.6964666",
"0.69481635",
"0.68660444",
"0.68279904",
"0.6752153",
"0.66779125",
"0.6638492",
"0.6627301",
"0.661... | 0.92478794 | 0 |
Generate corpus from dataset, remove label from every question. | def generate_corpus():
data = load_data()
questions = [s.split(' ', 1)[1].lower() for s in data]
return questions | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_text_classifier_del_training_samples_all(self):\n pass",
"def create_corpus(df):\r\n corpus=[]\r\n for tweet in tqdm(df['text']):\r\n words=[word.lower() for word in word_tokenize(tweet) if((word.isalpha()==1))]\r\n corpus.append(words)\r\n return corpus",
"def test_text_... | [
"0.6179051",
"0.61695355",
"0.612701",
"0.60080475",
"0.5991426",
"0.5968233",
"0.5966245",
"0.5962449",
"0.5961979",
"0.5824949",
"0.58028716",
"0.57764983",
"0.5754227",
"0.57507855",
"0.5742542",
"0.57408285",
"0.57311505",
"0.57246226",
"0.5599109",
"0.5594712",
"0.558772... | 0.7546315 | 0 |
Generate vocabulary from dataset and count their frequency. | def generate_vocabulary():
stop_words = load_stop_words()
words = ' '.join(generate_corpus()).split()
print(len(words))
vocabulary = {}
for word in words:
if word in stop_words:
continue
if word in vocabulary.keys():
vocabulary[word] += 1
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_dataset(words):\n count = []\n # count.extend(collections.Counter(words).most_common(n_words - 1))\n count.extend(collections.Counter(words).most_common())\n dictionary = dict()\n for word, _ in count:\n dictionary[word] = len(dictionary)\n data = list()\n # unk_count = 0\n for word in words:\... | [
"0.7119916",
"0.69955856",
"0.6780356",
"0.67377347",
"0.67227477",
"0.6565314",
"0.6564769",
"0.6538594",
"0.652457",
"0.64863276",
"0.64687914",
"0.6460493",
"0.64345866",
"0.6428765",
"0.6409645",
"0.64018935",
"0.6317153",
"0.6303987",
"0.62944937",
"0.62928957",
"0.62851... | 0.6724139 | 4 |
Write vocabulary to '../data/vocabulary.txt', each line contains a word and its frequency. | def write_vocabulary():
with open('../data/vocabulary.txt', 'w') as vocabulary_file:
vocabulary = generate_vocabulary()
word_count = sum(vocabulary.values())
print(word_count)
vocabs_str = [("%s %d" % (key, value)) for key, value in vocabulary.items()]
vocabulary_file.write('... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dump_vocab(vocab, path, encoding=\"Utf-8\"):\n with open(path, \"w\", encoding=encoding) as fout:\n for word, freq in vocab:\n fout.write(\"%s\\t%d\\n\" % (word, freq))",
"def write_vocabulary(vocab_processor, outfile):\n vocab_size = len(vocab_processor.vocabulary_)\n with open(outfil... | [
"0.77696854",
"0.76118624",
"0.75237185",
"0.74841684",
"0.7428175",
"0.7263195",
"0.7193403",
"0.7069946",
"0.6974747",
"0.6899833",
"0.67634916",
"0.67428726",
"0.67143416",
"0.66633344",
"0.6374416",
"0.63653886",
"0.6339275",
"0.6330938",
"0.6319669",
"0.631088",
"0.62634... | 0.8666452 | 0 |
Returns variable value from launch params | def get_action_var_val_from_launch_params(launch_vars, var_name):
filtered_launch_vars = list(
filter(
lambda e: e["name"] == var_name,
launch_vars,
)
)
if len(filtered_launch_vars) > 1:
LOG.error(
"Unable to populate runtime editables: Multiple ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getParameter(self, value):\n if value in self.commandLineDefaults:\n return self.commandLineDefaults[value]\n if value in self.defaults:\n return self.defaults[value]\n return None",
"def get_parm_value(parameters, name, env_name, default_value):\n value = parame... | [
"0.65366197",
"0.6387033",
"0.6228277",
"0.6148368",
"0.6089504",
"0.59744775",
"0.5972712",
"0.59664136",
"0.59335375",
"0.5925959",
"0.58825845",
"0.58721554",
"0.58434135",
"0.5822617",
"0.5805199",
"0.57746196",
"0.576227",
"0.5749721",
"0.5739871",
"0.57335603",
"0.57299... | 0.7026889 | 0 |
Returns patch arguments or variable data | def get_patch_runtime_args(
app_uuid, deployments, patch_payload, ignore_runtime_variables, runtime_params_file
):
patch_name = patch_payload["name"]
patch_args = {}
patch_args["patch"] = patch_payload
patch_args["variables"] = []
attrs_list = patch_payload["attrs_list"]
if ignore_runtim... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def patch_data(self):\n return get_json()",
"def patch(self):\n return self._get(\"patch\")",
"def arguments(self):\n return parse_arguments(self['data'])",
"def punkte(self):\n return self.args",
"def view_patch():\n\n return jsonify(\n get_dict(\"url\", \"args\", \"f... | [
"0.6376717",
"0.635689",
"0.5775939",
"0.57362425",
"0.5714351",
"0.56508195",
"0.55597174",
"0.55584913",
"0.54944223",
"0.5489795",
"0.5393315",
"0.5366492",
"0.53662485",
"0.53613627",
"0.5359275",
"0.5359163",
"0.5354778",
"0.53506154",
"0.53359705",
"0.53352034",
"0.5322... | 0.64711076 | 0 |
Returns action arguments or variable data | def get_action_runtime_args(
app_uuid, action_payload, patch_editables, runtime_params_file
):
action_name = action_payload["name"]
runtime_vars = {}
runbook_vars = action_payload["runbook"].get("variable_list", None) or []
for _var in runbook_vars:
editable_dict = _var.get("editables", No... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_action_params(self, a):\n return self.params[a]",
"def get_args(self, action):\n\n def args_function(wildcards):\n result = {\n \"input\": {\n \"reads_left\": list(\n sorted(self._collect_reads(wildcards, wildcards.library_... | [
"0.6437903",
"0.6257496",
"0.623383",
"0.62315136",
"0.61940783",
"0.61828846",
"0.6014103",
"0.60115045",
"0.5947184",
"0.5910995",
"0.58544385",
"0.5768185",
"0.5747866",
"0.57099986",
"0.56821144",
"0.56821144",
"0.5678529",
"0.56717134",
"0.5665467",
"0.5658113",
"0.56555... | 0.5925324 | 9 |
Download runlogs, given runlog uuid and app name | def download_runlog(runlog_id, app_name, file_name):
client = get_api_client()
app = _get_app(client, app_name)
app_id = app["metadata"]["uuid"]
if not file_name:
file_name = "runlog_{}.zip".format(runlog_id)
res, err = client.application.download_runlog(app_id, runlog_id)
if not err:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_run_logs(id_, **kwargs):\n run = get_run_object(id_)\n check_run_permission(run, kwargs[\"token_info\"])\n query = \"ilyde-run-{}\".format(run.id)\n return query_elasticsearch(query)",
"def download_workflow_log_files(repo, github_token, workflow_run_id, data_root_dir):\n headers = {... | [
"0.64194244",
"0.59884953",
"0.5788865",
"0.57788175",
"0.5744236",
"0.5743501",
"0.5706302",
"0.5553888",
"0.5492111",
"0.5492111",
"0.5474755",
"0.5382931",
"0.53668857",
"0.53567404",
"0.52949184",
"0.5284501",
"0.5284132",
"0.52608335",
"0.522752",
"0.5216262",
"0.5213479... | 0.77006644 | 0 |
Creates an output layout to work with a layout of screens Creates a output layout, which can be used to describing outputs in physical space relative to one another, and perform various useful operations on that state. | def __init__(self) -> None:
ptr = lib.wlr_output_layout_create()
self._ptr = ffi.gc(ptr, lib.wlr_output_layout_destroy)
self.add_event = Signal(ptr=ffi.addressof(ptr.events.add))
self.change_event = Signal(ptr=ffi.addressof(ptr.events.change))
self.destroy_event = Signal(ptr=ffi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _generate_layout(self):\n\n pass",
"def create_layout( self ):",
"def make_layout(self):\n\n for h in range(0, self.num_layout_heads):\n self.set_random_layout(h)\n self.set_local_layout(h)\n self.set_global_layout(h)\n\n self.check_and_propagate_first_... | [
"0.65080345",
"0.6411471",
"0.6406481",
"0.63220835",
"0.62492615",
"0.622953",
"0.61851484",
"0.6097497",
"0.60499716",
"0.601536",
"0.58365935",
"0.58044183",
"0.5791375",
"0.57711107",
"0.5690821",
"0.5674785",
"0.5657845",
"0.5563014",
"0.5554139",
"0.55327636",
"0.551320... | 0.56408554 | 17 |
Destroy the current output layout | def destroy(self) -> None:
if self._ptr is not None:
ffi.release(self._ptr)
self._ptr = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy(self):\n self.window.destroy_output_panel(self.name)",
"def remove(self, output: Output) -> None:\n lib.wlr_output_layout_remove(self._ptr, output._ptr)",
"def destroy(self):\r\n if self.cur_message is not None:\r\n self.cur_message.destroy()\r\n self.cur_... | [
"0.77853394",
"0.69212544",
"0.6771963",
"0.6771322",
"0.6740442",
"0.67121965",
"0.6695389",
"0.6649884",
"0.66008115",
"0.6560119",
"0.6526077",
"0.650882",
"0.64833146",
"0.6450388",
"0.64317787",
"0.6415468",
"0.6410194",
"0.64075977",
"0.63597274",
"0.63597274",
"0.63597... | 0.0 | -1 |
Add an auto configured output to the layout This will place the output in a sensible location in the layout. The coordinates of the output in the layout may adjust dynamically when the layout changes. If the output is already in the layout, it will become auto configured. If the position of the output is set such as wi... | def add_auto(self, output: Output) -> None:
lib.wlr_output_layout_add_auto(self._ptr, output._ptr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, output: Output, lx: int, ly: int) -> None:\n lib.wlr_output_layout_add(self._ptr, output._ptr, lx, ly)",
"def move(self, output: Output, lx: int, ly: int) -> None:\n lib.wlr_output_layout_move(self._ptr, output._ptr, lx, ly)",
"def output(self, layout: Optional[dict] = None) -> Outp... | [
"0.70198876",
"0.63294667",
"0.5761119",
"0.56359804",
"0.5577666",
"0.55675364",
"0.55489993",
"0.5502449",
"0.54143834",
"0.53270626",
"0.5263954",
"0.5225019",
"0.5154998",
"0.5103272",
"0.5067622",
"0.50329566",
"0.4984036",
"0.49752924",
"0.49733323",
"0.49177164",
"0.49... | 0.80270034 | 0 |
Determine coordinates of the output in the layout Given x and y in layout coordinates, adjusts them to local output coordinates relative to the given reference output. | def output_coords(self, output: Output) -> tuple[float, float]:
ox = ffi.new("double *")
oy = ffi.new("double *")
lib.wlr_output_layout_output_coords(self._ptr, output._ptr, ox, oy)
return ox[0], oy[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_position(layout):\n\n if layout.children:\n toyplot_vertical_align = layout.style[\"-toyplot-vertical-align\"]\n # Align the first line's baseline with the anchor.\n if toyplot_vertical_align == \"first-baseline\":\n offset_y = 0\n # Ali... | [
"0.6292434",
"0.60976356",
"0.60090214",
"0.5698411",
"0.567165",
"0.5587634",
"0.5562373",
"0.5496815",
"0.54904616",
"0.5438968",
"0.5402502",
"0.53729147",
"0.53563195",
"0.53547263",
"0.53337777",
"0.53318155",
"0.53305453",
"0.5305409",
"0.5298191",
"0.5286754",
"0.52553... | 0.6738363 | 0 |
Use the output layout in a context manager | def __enter__(self) -> OutputLayout:
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _do_layout(self):\n return",
"def layout(self):\n pass",
"def _generate_layout(self):\n\n pass",
"def output(self, layout: Optional[dict] = None) -> OutputWidget:\n return OutputWidget(self, layout)",
"def create_layout( self ):",
"def context(subcontext=None) -> None:\n ... | [
"0.64091706",
"0.6069155",
"0.5997315",
"0.5928173",
"0.58884573",
"0.5709779",
"0.5672082",
"0.5537715",
"0.5532014",
"0.5498159",
"0.548384",
"0.5475992",
"0.5458588",
"0.54453886",
"0.53986293",
"0.53619075",
"0.53441685",
"0.5322948",
"0.53207755",
"0.5281953",
"0.5273164... | 0.719726 | 0 |
Clean up the output layout when exiting the context | def __exit__(self, exc_type, exc_value, exc_tb) -> None:
self.destroy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def horde_cleanup(self):",
"def handle_caught(self):\n self.destroy()\n \n #---------------------------------------------------------------------------------------------------------------------------------------------------------#\n \n #-----------------------------------------... | [
"0.6551884",
"0.650356",
"0.6438108",
"0.63920903",
"0.63920903",
"0.63920903",
"0.63851225",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63832134",
"0.63735616",
"0.63735616",
... | 0.0 | -1 |
Get the output at the specified layout coordinates. Returns None if no output matches the coordinates. | def output_at(self, x: float, y: float) -> Output | None:
output_ptr = lib.wlr_output_layout_output_at(self._ptr, x, y)
if output_ptr == ffi.NULL:
return None
return Output(output_ptr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output_coords(self, output: Output) -> tuple[float, float]:\n ox = ffi.new(\"double *\")\n oy = ffi.new(\"double *\")\n lib.wlr_output_layout_output_coords(self._ptr, output._ptr, ox, oy)\n\n return ox[0], oy[0]",
"def get_output_by_name(self, name):\n for var in self.outpu... | [
"0.6571606",
"0.5839956",
"0.56035906",
"0.54842794",
"0.5437366",
"0.5349081",
"0.5301348",
"0.5281909",
"0.51899874",
"0.5155416",
"0.5151213",
"0.51356196",
"0.51304936",
"0.5116058",
"0.5116058",
"0.5091115",
"0.5090367",
"0.5016866",
"0.5016222",
"0.49573547",
"0.4944155... | 0.7370843 | 0 |
Add the output to the layout at the specified coordinates. If the output is already part of the output layout, this moves the output. | def add(self, output: Output, lx: int, ly: int) -> None:
lib.wlr_output_layout_add(self._ptr, output._ptr, lx, ly) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move(self, output: Output, lx: int, ly: int) -> None:\n lib.wlr_output_layout_move(self._ptr, output._ptr, lx, ly)",
"def add_node_output_locations(self, xy,epsgIN,start,end,step): \n nodeIds = self.grid.get_node_output_locations(xy,epsgIN)\n if(elementIds != []):\n se... | [
"0.6960685",
"0.60513806",
"0.60398746",
"0.5813254",
"0.575669",
"0.56998533",
"0.56029904",
"0.5567559",
"0.54616624",
"0.5377717",
"0.53622025",
"0.5348922",
"0.5346724",
"0.5326581",
"0.53180915",
"0.5304156",
"0.5291399",
"0.52477604",
"0.51817405",
"0.5181331",
"0.51578... | 0.7201141 | 0 |
Move an output to specified coordinates. | def move(self, output: Output, lx: int, ly: int) -> None:
lib.wlr_output_layout_move(self._ptr, output._ptr, lx, ly) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def move_to(self, destination_coords):\n self.x = destination_coords[0]\n self.y = destination_coords[1]\n return",
"def move(self, coordinates, direction):\n pass",
"def instantiate_output_move(row, col, row_idx_bitwidth, col_idx_bitwidth):\n group_name = py_ast.CompVar(\n ... | [
"0.66784644",
"0.64650375",
"0.63968575",
"0.6348587",
"0.6258059",
"0.6240109",
"0.62277734",
"0.62160134",
"0.61788344",
"0.6122616",
"0.60436296",
"0.60330397",
"0.60210365",
"0.59689134",
"0.5945228",
"0.59423894",
"0.59325606",
"0.5914747",
"0.58816713",
"0.5859127",
"0.... | 0.7212036 | 0 |
Remove an output from the layout. | def remove(self, output: Output) -> None:
lib.wlr_output_layout_remove(self._ptr, output._ptr) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_layout(self, layout: Layout):\n self.layouts.pop(layout, None)",
"def removeLayout(self, *args):\n return _libsbml.LayoutModelPlugin_removeLayout(self, *args)",
"def removeOutput(self, *args):\n return _libsbml.Transition_removeOutput(self, *args)",
"def destroy(self):\n ... | [
"0.7089926",
"0.68975186",
"0.6884714",
"0.6528211",
"0.63225365",
"0.6296304",
"0.6290189",
"0.6283299",
"0.62830955",
"0.62702155",
"0.626779",
"0.62561774",
"0.62509525",
"0.6069614",
"0.6065491",
"0.6051975",
"0.60506624",
"0.5988264",
"0.5982314",
"0.59661174",
"0.585206... | 0.849233 | 0 |
Get the box of the layout for the given reference output in layout coordinates. If `reference` is None, the box will be for the extents of the entire layout. If the output isn't in the layout, the box will be empty. | def get_box(
self, reference: Output | None = None, dest_box: Box | None = None
) -> Box:
if reference:
reference_ptr = reference._ptr
else:
reference_ptr = ffi.NULL
if not dest_box:
dest_box = Box(ptr=ffi.new("struct wlr_box *"))
lib.wlr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_bounding_box(self):\n if not isinstance(self.ref_cell, Cell):\n return None\n if self.rotation is None or self.rotation % 90 == 0:\n cell_bbox = self.ref_cell.get_bounding_box()\n if cell_bbox is None:\n return None\n polygons = self.... | [
"0.5901545",
"0.58824706",
"0.5489302",
"0.5370161",
"0.53481007",
"0.5327489",
"0.5279537",
"0.5278215",
"0.5267045",
"0.51329285",
"0.51328117",
"0.5108612",
"0.5098542",
"0.5029901",
"0.49236295",
"0.49177372",
"0.48856136",
"0.48354876",
"0.47964993",
"0.47919694",
"0.479... | 0.7389529 | 0 |
Get the closest point on this layout from the given point from the reference output. If reference is NULL, gets the closest point from the entire layout. | def closest_point(
self, lx: float, ly: float, reference: Output | None = None
) -> tuple[float, float]:
if reference:
reference_ptr = reference._ptr
else:
reference_ptr = ffi.NULL
dest_lx = ffi.new("double *")
dest_ly = ffi.new("double *")
li... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def closest_point(self, point, maxdist=0.0, return_param=False):\n return self.xyz",
"def closest_point_to(self, x):\n x = np.array(x)\n v = self.p1 - self.p0\n b = self.p0 - x\n\n t = -np.dot(v, b) / np.dot(v, v)\n if (0 <= t <= 1):\n closest = t*(self.p1 - s... | [
"0.68781555",
"0.6766535",
"0.6657588",
"0.66149604",
"0.6594103",
"0.65055597",
"0.64913166",
"0.6426414",
"0.64132017",
"0.63651127",
"0.62755954",
"0.624393",
"0.6239674",
"0.62271637",
"0.6206133",
"0.60887647",
"0.6084108",
"0.60477453",
"0.60337806",
"0.6023641",
"0.601... | 0.76994383 | 0 |
Sets the current_state to the initial_state (0) and sets input_symbol to None. | def reset (self):
self.currentState = self.initialState
self.inputSymbol = None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _reset_state(self):\n self.state = self.start_state.copy()",
"def _reset_for_new_walk(self):\n # Starting State\n self.state = State('start', 0, 1, 0, 0, self.state_space_parameters.input_size, 0, 0, False)\n\n # Architecture String\n self.state_list = [self.state.copy()]",... | [
"0.65661925",
"0.64960563",
"0.6418424",
"0.6401293",
"0.6351065",
"0.6345368",
"0.6306686",
"0.62734896",
"0.6161061",
"0.6148739",
"0.6071161",
"0.60412455",
"0.6023714",
"0.6023049",
"0.6021861",
"0.6006364",
"0.598042",
"0.5976253",
"0.5970858",
"0.5970858",
"0.5970858",
... | 0.83541876 | 0 |
This sets the default transition. This defines an action and next_state if the FSM cannot find the input symbol provided by the user and the current state in the transition list. The default transition can be removed by setting the attribute defaultTransition to None. In this case, for default the nextState will be the... | def setDefaultTransition (self, action, nextState):
if nextState is not None:
self.defaultTransition = (action, nextState)
else:
self.defaultTransition = (action, self.initialState) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getTransition (self, inputSymbol, state):\n\n if (inputSymbol, state) in self.stateTransitions:\n return self.stateTransitions[(inputSymbol, state)]\n elif self.defaultTransition is not None:\n return self.defaultTransition\n else:\n raise ExceptionFSM ('Tr... | [
"0.5937508",
"0.58190686",
"0.5759606",
"0.57087535",
"0.5651682",
"0.565062",
"0.5649066",
"0.56352",
"0.5580734",
"0.5491866",
"0.5468211",
"0.5421407",
"0.53243065",
"0.52767915",
"0.5274182",
"0.5246616",
"0.5239235",
"0.5184615",
"0.51798594",
"0.5175904",
"0.5171481",
... | 0.77794313 | 0 |
This method returns the tuples (action, next state) given an inputSymbol and state. | def getTransition (self, inputSymbol, state):
if (inputSymbol, state) in self.stateTransitions:
return self.stateTransitions[(inputSymbol, state)]
elif self.defaultTransition is not None:
return self.defaultTransition
else:
raise ExceptionFSM ('Transition is ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_next_state(self, state, action):\n pass",
"def p(self, next_state, state, action):\n\n return self._p[state, next_state, action]",
"def process (self, inputSymbol):\n \n self.inputSymbol = inputSymbol\n (self.action, self.nextState) = self.getTransition (self.inputSymbol,... | [
"0.7005093",
"0.6508219",
"0.6507524",
"0.6235809",
"0.6222719",
"0.6205359",
"0.6205105",
"0.60368776",
"0.5969271",
"0.5955513",
"0.59514",
"0.59455127",
"0.5928941",
"0.5909269",
"0.5861482",
"0.58402",
"0.5836453",
"0.58101356",
"0.58081824",
"0.58023584",
"0.5797929",
... | 0.6625956 | 1 |
This is the main method that process user input. This cause the FSM to change state and call an action. This method calls getTransition() to find the correct action and nextState associated with the inputSymbol and currentState. This method processes one complete input symbol. | def process (self, inputSymbol):
self.inputSymbol = inputSymbol
(self.action, self.nextState) = self.getTransition (self.inputSymbol, self.currentState)
if self.action is not None:
self.action (self)
self.memoryState.append(self.currentState)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def input(self, symbol, *args, **kwargs):\n if self.__state is None:\n raise ValueError(\"FSM state is undefined\")\n try:\n transition = self.__get_state_attr(self._transition_prefix)\n except AttributeError:\n raise Exception(\"unable to find transition funct... | [
"0.7126944",
"0.6313032",
"0.6273754",
"0.6034373",
"0.5996154",
"0.5985508",
"0.59294426",
"0.58302075",
"0.58178115",
"0.5808534",
"0.57349867",
"0.5706727",
"0.5656725",
"0.5618711",
"0.56094056",
"0.5534585",
"0.5453117",
"0.5448634",
"0.54410994",
"0.5429249",
"0.5428419... | 0.80351883 | 0 |
Here the FSM is stared and the state transitions are defined. | def main():
f = FiniteStatesMachine('stopped', [])
f.setDefaultTransition(Error, None)
f.addTransitionList('start', 'stopped', starFSMVariables, 'started')
f.addTransitionList('collect', 'started', collectData, 'collecting')
f.addTransitionList('collect', 'processing',... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def leaderFiniteStateMachine(self):\n if(self.mode == 'simulation'):\n print(self.name + \": Actualizamos la maquina de estado del lider\")\n \n else:\n if(self.current_state == EMERGENCY or self.current_state == UNDEFINED): # No puede salir de EMERGENCIA, hay que reinic... | [
"0.6921972",
"0.69081324",
"0.68047744",
"0.67634577",
"0.6744643",
"0.6723987",
"0.67230344",
"0.6710408",
"0.6695104",
"0.6627893",
"0.656548",
"0.65531117",
"0.65408266",
"0.6513487",
"0.6502165",
"0.6502138",
"0.64529026",
"0.64302516",
"0.6429017",
"0.6428415",
"0.642449... | 0.6766668 | 3 |
Generates parsing spec for tf.parse_example to be used with classifiers. If users keep data in tf.Example format, they need to call tf.parse_example | def classifier_parse_example_spec(feature_columns,
label_key,
label_dtype=dtypes.int64,
label_default=None,
weight_column=None):
parsing_spec = fc.make_parse_example_spec(feature_col... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tf_example_parser(example):\n def _get_feature_map():\n \"\"\"Returns data format of the serialized tf record file.\"\"\"\n return {\n # 3 sparse feature with variable length. Use this if you have a\n # variable number or more than 1 feature value per example.\n \"featur... | [
"0.7969642",
"0.77698576",
"0.7314053",
"0.7263414",
"0.72264713",
"0.71797144",
"0.7169134",
"0.7144098",
"0.70959514",
"0.7066097",
"0.704645",
"0.702182",
"0.69985455",
"0.6914308",
"0.68740547",
"0.68440163",
"0.68436134",
"0.6774798",
"0.6757371",
"0.66926384",
"0.663061... | 0.0 | -1 |
Generates parsing spec for tf.parse_example to be used with regressors. If users keep data in tf.Example format, they need to call tf.parse_example | def regressor_parse_example_spec(feature_columns,
label_key,
label_dtype=dtypes.float32,
label_default=None,
label_dimension=1,
weight_column=None):
pars... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tf_example_parser(example):\n def _get_feature_map():\n \"\"\"Returns data format of the serialized tf record file.\"\"\"\n return {\n # 3 sparse feature with variable length. Use this if you have a\n # variable number or more than 1 feature value per example.\n \"featur... | [
"0.8089116",
"0.7692144",
"0.7427058",
"0.73363465",
"0.7304736",
"0.72581846",
"0.7235934",
"0.7229534",
"0.7021413",
"0.70062184",
"0.69566554",
"0.69477016",
"0.69340587",
"0.69241685",
"0.6892932",
"0.6824007",
"0.6796293",
"0.6792499",
"0.6732977",
"0.67035663",
"0.66994... | 0.0 | -1 |
Read the AWS from the credentials dictionary and then create a boto3 connection to AWS with those credentials. | def create_session(credentials):
if type(credentials) == dict:
pass
elif type(credentials) == str:
credentials = json.loads(credentials)
else:
credentials = json.load(credentials)
session = Session(aws_access_key_id = credentials["aws_access_key"],
aws_secr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _connect_to_s3(self, credentials):\n connection = s3.S3Connection(credentials['token'], credentials['secret'])\n bucket = connection.get_bucket(credentials['bucket'])\n return connection, bucket",
"def authenticate(self, credentials=None):\n if credentials is None: # pragma: no cover\n ... | [
"0.7304738",
"0.68542176",
"0.6808308",
"0.67948496",
"0.663381",
"0.65727234",
"0.6560181",
"0.6550317",
"0.6514393",
"0.6512412",
"0.6453467",
"0.6438175",
"0.6430765",
"0.64142025",
"0.6409353",
"0.63990295",
"0.63990295",
"0.63990295",
"0.6398798",
"0.63965577",
"0.639609... | 0.6753502 | 4 |
Create a session with no credentials, meant to be used by internal instance with assumed iam role. | def use_iam_role():
session = Session(region_name='us-east-1')
return session | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_session(self, **params):\n raise NotImplementedError('Should be implemented by a sub-class.')",
"def create_session(self):\n self._session = self.create_scoped_session()\n self.session = self._session()",
"def create_session(credentials):\n if type(credentials) == dict:\n ... | [
"0.6815272",
"0.6593538",
"0.64895034",
"0.640303",
"0.63064355",
"0.6300941",
"0.6279542",
"0.62607354",
"0.6249621",
"0.6249621",
"0.6246718",
"0.6229943",
"0.6218699",
"0.61909324",
"0.61593825",
"0.6153288",
"0.6141328",
"0.6137293",
"0.6135626",
"0.61204773",
"0.6110543"... | 0.62233883 | 12 |
Lookup all of the IP addresses for a given AWS instance name. Multiple instances with the same name is a result of instances belonging to an auto scale group. Useful when an action needs to happen to all machines in an auto scale group. | def machine_lookup_all(session, hostname, public_ip = True):
client = session.client('ec2')
response = client.describe_instances(Filters=[{"Name":"tag:Name", "Values":[hostname]},
{"Name":"instance-state-name", "Values":["running"]}])
addresses = []
ite... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_instances_by_name_mask(self, mask_name):\n\n instances = []\n\n instance_list = self.nova_cli.servers.list()\n logger.info('Instances list is {0}'.format(instance_list))\n logger.info(\n 'Expected instance name should inlude {0}'.format(mask_name))\n\n for ins... | [
"0.690664",
"0.684622",
"0.6602771",
"0.61565304",
"0.6142604",
"0.60926044",
"0.60590464",
"0.60518944",
"0.60219425",
"0.60186154",
"0.6005966",
"0.5953812",
"0.5896932",
"0.5894132",
"0.5887551",
"0.5881828",
"0.5880497",
"0.58594406",
"0.58584875",
"0.5843627",
"0.5772551... | 0.6998335 | 0 |
Lookup the IP addresses for a given AWS instance name. | def machine_lookup(session, hostname, public_ip = True):
try:
idx, target = hostname.split('.', 1)
idx = int(idx) # if it is not a valid number, then it is a hostname
hostname = target
except:
idx = 0
client = session.client('ec2')
response = client.describe_instances(F... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ips(rg_name, vmss_name):\n\n script = \"az vmss list-instance-public-ips --resource-group {rg} --name {vmss} | grep ipAddress\".format(\n rg=rg_name,\n vmss=vmss_name\n )\n run_script(script)",
"def machine_lookup_all(session, hostname, public_ip = True):\n client = session.clie... | [
"0.70247114",
"0.6887101",
"0.6677439",
"0.6462593",
"0.6427537",
"0.63524264",
"0.61925566",
"0.61001545",
"0.60729104",
"0.59737617",
"0.5951085",
"0.59333456",
"0.5926617",
"0.5926617",
"0.59114546",
"0.5910869",
"0.5896637",
"0.58187497",
"0.5816545",
"0.5800161",
"0.5798... | 0.6471544 | 3 |
Lookup the public DNS for a given AWS RDS instance name. | def rds_lookup(session, hostname):
client = session.client('rds')
response = client.describe_db_instances(DBInstanceIdentifier=hostname)
item = response['DBInstances']
if len(item) == 0:
print("Could not find DNS for '{}'".format(hostname))
return None
else:
return item[0][... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def instance_public_lookup(session, hostname):\n if session is None:\n return None\n\n client = session.client('ec2')\n response = client.describe_instances(\n Filters=[{\"Name\": \"tag:Name\", \"Values\": [hostname]},\n {\"Name\": \"instance-state-name\", \"Values\": [\"runn... | [
"0.7454354",
"0.6793534",
"0.64854825",
"0.638419",
"0.637897",
"0.63712627",
"0.63638",
"0.6352668",
"0.62254494",
"0.6122659",
"0.60128444",
"0.59898543",
"0.59575254",
"0.59271836",
"0.58951855",
"0.58788455",
"0.5849263",
"0.58443725",
"0.5781869",
"0.5759335",
"0.5698314... | 0.780593 | 0 |
Locate an item in a list based on a predicate function. | def _find(xs, predicate):
for x in xs:
if predicate(x):
return x
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find(func, list_seq):\n for list_item in list_seq:\n if func(list_item):\n return list_item",
"def list_find(f, items):\n for i, x in enumerate(items):\n if f(x):\n return i\n return None",
"def finditem(func, seq):\n return next((item for item in seq if func... | [
"0.7345009",
"0.7329399",
"0.69864964",
"0.68509775",
"0.6848589",
"0.6835385",
"0.6782268",
"0.67755824",
"0.631964",
"0.63177335",
"0.62872744",
"0.6159832",
"0.60666436",
"0.60513777",
"0.60492444",
"0.60366356",
"0.59750605",
"0.59668785",
"0.5961629",
"0.595214",
"0.5874... | 0.7533438 | 0 |
Terminate all of the instances for an ASG, with the given timeout between each termination. | def asg_restart(session, hostname, timeout, callback=None):
client = session.client('ec2')
resource = session.resource('ec2')
response = client.describe_instances(Filters=[{"Name":"tag:Name", "Values":[hostname]},
{"Name":"instance-state-name", "Values":["ru... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def terminate_all(self):\n self._stop_all('terminate')",
"def terminate_instances(self, ids):\n self.conn.terminate_instances(instance_ids=ids)",
"def terminate_instances(self, props):\n return self._vm_async_apply(props, 'delete')",
"def terminate_instance_in_asg(instance_id):\n if n... | [
"0.6357317",
"0.6248194",
"0.6084295",
"0.59850127",
"0.5979804",
"0.5917791",
"0.5914561",
"0.58749413",
"0.5839589",
"0.5790333",
"0.5714129",
"0.56740266",
"0.56631154",
"0.5644305",
"0.5632723",
"0.5591108",
"0.557721",
"0.5561397",
"0.55381894",
"0.5480454",
"0.5472366",... | 0.6897586 | 0 |
Lookup the Group name for the ASG creating the EC2 instances with the given hostname | def asg_name_lookup(session, hostname):
if session is None:
return None
client = session.client('autoscaling')
response = client.describe_auto_scaling_groups()
if len(response['AutoScalingGroups']) == 0:
return None
else:
# DP NOTE: Unfortunatly describe_auto_scaling_groups(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def instanceid_lookup(session, hostname):\n if session is None:\n return None\n\n client = session.client('ec2')\n response = client.describe_instances(\n Filters=[{\"Name\": \"tag:Name\", \"Values\": [hostname]}])\n\n item = response['Reservations']\n if len(item) == 0:\n retur... | [
"0.63809437",
"0.63582885",
"0.62746876",
"0.62431866",
"0.61943334",
"0.6136143",
"0.6110822",
"0.6015477",
"0.5964197",
"0.5958102",
"0.59372044",
"0.5880964",
"0.583179",
"0.57972753",
"0.57745284",
"0.57554305",
"0.57206607",
"0.57174826",
"0.5665552",
"0.5599069",
"0.559... | 0.7942209 | 0 |
Lookup the Id for the VPC with the given domain name. | def vpc_id_lookup(session, vpc_domain):
if session is None:
return None
client = session.client('ec2')
response = client.describe_vpcs(Filters=[{"Name": "tag:Name", "Values": [vpc_domain]}])
if len(response['Vpcs']) == 0:
return None
else:
return response['Vpcs'][0]['VpcId'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_keystone_v3_domain_id(self, domain_name):\n LOG_OBJ.debug(\"Get the domain ID.\")\n\n _url = \"http://\" + self.host_ip + \":35357/v3/domains?name=\" + \\\n str(domain_name)\n _headers = {'x-auth-token': self.cloud_admin_info[\"token_domain\"],\n 'conte... | [
"0.7072395",
"0.66890675",
"0.62828547",
"0.60626096",
"0.60512835",
"0.60456634",
"0.60456634",
"0.5988567",
"0.5966641",
"0.5933054",
"0.5929906",
"0.5865763",
"0.5865732",
"0.5855496",
"0.5855496",
"0.5855496",
"0.5855496",
"0.5855496",
"0.5855496",
"0.583406",
"0.5822499"... | 0.81332946 | 0 |
Lookup the Id for the Subnet with the given domain name. | def subnet_id_lookup(session, subnet_domain):
if session is None:
return None
client = session.client('ec2')
response = client.describe_subnets(Filters=[{"Name": "tag:Name", "Values": [subnet_domain]}])
if len(response['Subnets']) == 0:
return None
else:
return response['Sub... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_keystone_v3_domain_id(self, domain_name):\n LOG_OBJ.debug(\"Get the domain ID.\")\n\n _url = \"http://\" + self.host_ip + \":35357/v3/domains?name=\" + \\\n str(domain_name)\n _headers = {'x-auth-token': self.cloud_admin_info[\"token_domain\"],\n 'conte... | [
"0.62816155",
"0.6252993",
"0.61216253",
"0.6116545",
"0.57401055",
"0.56873554",
"0.5656026",
"0.5638093",
"0.56223834",
"0.5614454",
"0.5596863",
"0.5574551",
"0.55497974",
"0.5529772",
"0.5517432",
"0.5475204",
"0.5445243",
"0.5445243",
"0.54308754",
"0.54301274",
"0.54301... | 0.7532417 | 0 |
Lookup all of the Availablity Zones for the connected region. | def azs_lookup(session, lambda_compatible_only=False):
if session is None:
return []
client = session.client('ec2')
response = client.describe_availability_zones()
# SH Removing Hack as subnet A is already in Production and causes issues trying to delete
# We will strip out subnets A and... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_zones(self):\n path = '/os-availability-zone/detail'\n res = self.compute.call(path, 'GET', data='', \n token=self.manager.identity.token)\n self.logger.debug('Get openstack availability zone: %s' % truncate(res))\n return res[0]['availabilityZ... | [
"0.64122",
"0.6283016",
"0.6114804",
"0.6100205",
"0.58681506",
"0.58634186",
"0.58540446",
"0.57796514",
"0.5697409",
"0.56809247",
"0.5643406",
"0.56392354",
"0.5632144",
"0.55650926",
"0.5555251",
"0.5555251",
"0.5555251",
"0.5555251",
"0.5555251",
"0.5555251",
"0.5512116"... | 0.4891052 | 85 |
Lookup the Id for the AMI with the given name. If ami_name ends with '.boss', the AMI_VERSION environmental variable is used to either search for the latest commit hash tagged AMI ('.bossh') or for the AMI with the specific tag ('.boss'). | def ami_lookup(session, ami_name, version = None):
if session is None:
return None
specific = False
if ami_name.endswith(".boss"):
ami_version = os.environ["AMI_VERSION"] if version is None else version
if ami_version == "latest":
# limit latest searching to only version... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ami_by_name ( ec2_conn, ami_name ) :\n amis = ec2_conn.get_all_images( filters = { \"name\": [ ami_name ] } )\n for ami in amis :\n return ami",
"def get_ami_by_id ( ec2_conn, ami_id ) :\n amis = ec2_conn.get_all_images( image_ids = [ ami_id ] )\n for ami in amis :\n return ami",
"d... | [
"0.6669751",
"0.5976176",
"0.58265173",
"0.5811249",
"0.5770496",
"0.56842625",
"0.56431633",
"0.56096363",
"0.5589823",
"0.55881256",
"0.5372395",
"0.53390926",
"0.5291101",
"0.5243476",
"0.51454204",
"0.5121465",
"0.50918853",
"0.5083589",
"0.5083099",
"0.507428",
"0.506357... | 0.74430376 | 0 |
Lookup the Ids for all of the VPC Security Groups. | def sg_lookup_all(session, vpc_id):
if session is None:
return NoneDict()
client = session.client('ec2')
response = client.describe_security_groups(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])
if len(response['SecurityGroups']) == 0:
return NoneDict()
else:
sgs = NoneD... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sg_ids(vpc):\n list = [i.id for i in vpc.security_groups.all()]\n return list",
"def vpc_security_group_ids(self) -> pulumi.Output[Sequence[str]]:\n return pulumi.get(self, \"vpc_security_group_ids\")",
"def vpc_security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]... | [
"0.776428",
"0.7407091",
"0.7198566",
"0.7198566",
"0.68077105",
"0.68063724",
"0.67918974",
"0.6652626",
"0.66312367",
"0.66312367",
"0.63980854",
"0.6179441",
"0.6063443",
"0.5990153",
"0.59719115",
"0.59415746",
"0.5895164",
"0.58848244",
"0.5872261",
"0.5848759",
"0.58404... | 0.7723206 | 1 |
Lookup the Id for the VPC Security Group with the given name. | def sg_lookup(session, vpc_id, group_name):
if session is None:
return None
client = session.client('ec2')
response = client.describe_security_groups(Filters=[{"Name": "vpc-id", "Values": [vpc_id]},
{"Name": "tag:Name", "Values": [group_name]}... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sg_id(sg_name):\n print()\n print(\"Searching for SG ID\")\n client = boto3.client('ec2')\n all_sg = client.describe_security_groups()\n print(sg_name)\n grp_id = \"None\"\n for sec_grp in all_sg['SecurityGroups']:\n print(sec_grp['GroupName'])\n if sg_name == sec_grp['Gr... | [
"0.7680698",
"0.7084317",
"0.6718247",
"0.66819984",
"0.66819984",
"0.6648008",
"0.6648008",
"0.6557056",
"0.65039665",
"0.6483536",
"0.6483536",
"0.6401095",
"0.63624",
"0.62879884",
"0.62802815",
"0.6271635",
"0.62600183",
"0.60661876",
"0.6065279",
"0.5980223",
"0.5909057"... | 0.81316435 | 0 |
Lookup the Id for the VPC Route Table with the given name. | def rt_lookup(session, vpc_id, rt_name):
if session is None:
return None
client = session.client('ec2')
response = client.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc_id]},
{"Name": "tag:Name", "Values": [rt_name]}])
if l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_id(self, tag_name):\n response = await self.describe(tag_name)\n if response['RouteTables']:\n return response['RouteTables'][0][\"RouteTableId\"]\n else:\n raise RtbDoesntExists",
"def transit_router_route_table_id(self) -> Optional[pulumi.Input[str]]:\n ... | [
"0.7265778",
"0.6650314",
"0.6650314",
"0.65430045",
"0.65120596",
"0.64262307",
"0.6146517",
"0.60185033",
"0.56920457",
"0.5620676",
"0.5594443",
"0.5552543",
"0.5518078",
"0.5444758",
"0.54276913",
"0.5355043",
"0.5323631",
"0.5280393",
"0.5248865",
"0.52361125",
"0.522494... | 0.7589303 | 0 |
Name the default Route Table that is created for a new VPC. Find the default VPC Route Table and give it a name so that it can be referenced latter. Needed because by default the Route Table does not have a name and rt_lookup() will not find it. The default VPC Route Table is determined as the first Route Table without... | def rt_name_default(session, vpc_id, new_rt_name):
client = session.client('ec2')
response = client.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])
rt_id = None
for rt in response['RouteTables']:
nt = _find(rt['Tags'], lambda x: x['Key'] == 'Name')
if nt is None ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rt_lookup(session, vpc_id, rt_name):\n if session is None:\n return None\n\n client = session.client('ec2')\n response = client.describe_route_tables(Filters=[{\"Name\": \"vpc-id\", \"Values\": [vpc_id]},\n {\"Name\": \"tag:Name\", \"Values\":... | [
"0.6255291",
"0.5958707",
"0.5942567",
"0.58998066",
"0.5847473",
"0.5646883",
"0.5562245",
"0.5402062",
"0.54012924",
"0.5368249",
"0.5318241",
"0.52420455",
"0.5207002",
"0.51904994",
"0.5187961",
"0.516698",
"0.51573324",
"0.5153503",
"0.5133534",
"0.51282156",
"0.5078571"... | 0.84361637 | 0 |
Lookup the Id for the Peering Connection between the two VPCs. | def peering_lookup(session, from_id, to_id, owner_id=None):
if session is None:
return None
if owner_id is None:
owner_id = get_account_id_from_session(session)
client = session.client('ec2')
response = client.describe_vpc_peering_connections(Filters=[{"Name": "requester-vpc-info.vpc-i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def peering_connection_id(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"peering_connection_id\")",
"def peering_connection_id(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"peering_connection_id\")",
"def connection_id(self) -> pulumi.Output[str]:\n return pul... | [
"0.7403329",
"0.70283127",
"0.6273366",
"0.60336775",
"0.5969494",
"0.5969494",
"0.5969494",
"0.5969494",
"0.5969494",
"0.5969494",
"0.5954346",
"0.5914856",
"0.58613765",
"0.5849268",
"0.581425",
"0.581425",
"0.581425",
"0.581425",
"0.581425",
"0.581425",
"0.581425",
"0.58... | 0.6654912 | 2 |
Lookup the names of valid Key Pair. If the SSH_KEY enviro variable is defined and points to a valid keypair, that keypair name is returned. Else all of the keypairs are printed to stdout and the user is prompted to select which keypair to use. | def keypair_lookup(session):
if session is None:
return None
client = session.client('ec2')
response = client.describe_key_pairs()
# If SSH_KEY exists and points to a valid Key Pair, use it
key = os.environ.get("SSH_KEY", None) # reuse bastion.py env vars
if key is not None:
k... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_key_pair(ec2, kp_name):\n if not [i for i in ec2.get_all_key_pairs() if str(i).split(':')[1] == kp_name]:\n sys.stderr.write(\"Key pair: {} does not exist, please import_key_pair prior to running.\\n\".format(kp_name))\n sys.exit(1)",
"def key_pair_name(self) -> Optional[pulumi.Input[s... | [
"0.6621088",
"0.61450076",
"0.61450076",
"0.6030742",
"0.5993051",
"0.5961809",
"0.58859694",
"0.5711315",
"0.55931115",
"0.5490621",
"0.54890466",
"0.5479529",
"0.54452103",
"0.5428441",
"0.54208297",
"0.5379685",
"0.5375169",
"0.53638816",
"0.53498614",
"0.5281988",
"0.5258... | 0.78218615 | 0 |
Look up instance id by hostname (instance name). | def instanceid_lookup(session, hostname):
if session is None:
return None
client = session.client('ec2')
response = client.describe_instances(
Filters=[{"Name": "tag:Name", "Values": [hostname]}])
item = response['Reservations']
if len(item) == 0:
return None
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getHostKey(instance):\n return instance['hostname']",
"def get_instance_id(self):\n return \"{0}-{1}\".format(self._vc_name, self._host)",
"def instance_public_lookup(session, hostname):\n if session is None:\n return None\n\n client = session.client('ec2')\n response = client.des... | [
"0.7457449",
"0.7274183",
"0.7065669",
"0.7018674",
"0.69828963",
"0.6804619",
"0.6804448",
"0.66520125",
"0.665048",
"0.66439986",
"0.65985245",
"0.6568026",
"0.654998",
"0.6524222",
"0.65042883",
"0.65042883",
"0.65042883",
"0.64500105",
"0.6423488",
"0.6423488",
"0.6423488... | 0.8307429 | 0 |
Looks up the ARN for a SSL Certificate | def cert_arn_lookup(session, domain_name):
if session is None:
return None
client = session.client('acm')
response = client.list_certificates()
for certs in response['CertificateSummaryList']:
if certs['DomainName'] == domain_name:
return certs['CertificateArn']
if c... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_ssl_certificate_arn(environment):\n name = Constants['SslCertificateName'][environment]\n\n certificates = ACM.list_certificates(CertificateStatuses=[ 'ISSUED' ])['CertificateSummaryList']\n arns = [ c['CertificateArn'] for c in certificates if c['DomainName'] == name ]\n\n if len(arns) == 0:\n... | [
"0.7575733",
"0.67465764",
"0.64577544",
"0.64160997",
"0.628164",
"0.6254604",
"0.6073698",
"0.5756983",
"0.5599451",
"0.5599451",
"0.5599451",
"0.5577368",
"0.5577368",
"0.5577027",
"0.5553289",
"0.5553289",
"0.5549295",
"0.5541539",
"0.550942",
"0.5448711",
"0.5382661",
... | 0.7114357 | 1 |
Lookup the Public DNS name for a EC2 instance | def instance_public_lookup(session, hostname):
if session is None:
return None
client = session.client('ec2')
response = client.describe_instances(
Filters=[{"Name": "tag:Name", "Values": [hostname]},
{"Name": "instance-state-name", "Values": ["running"]}])
item = resp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rds_lookup(session, hostname):\n\n client = session.client('rds')\n response = client.describe_db_instances(DBInstanceIdentifier=hostname)\n\n item = response['DBInstances']\n if len(item) == 0:\n print(\"Could not find DNS for '{}'\".format(hostname))\n return None\n else:\n ... | [
"0.7093993",
"0.6950115",
"0.69366145",
"0.6753267",
"0.6640436",
"0.66227126",
"0.6474817",
"0.6400321",
"0.6302448",
"0.62650925",
"0.6223052",
"0.6206862",
"0.61611843",
"0.6119791",
"0.60280055",
"0.6024374",
"0.6014244",
"0.6009959",
"0.5994625",
"0.5985246",
"0.59798884... | 0.77868897 | 0 |
Lookup cloudfront public domain name which has hostname as the origin. | def cloudfront_public_lookup(session, hostname):
if session is None:
return None
client = session.client('cloudfront')
response = client.list_distributions(
MaxItems='100'
)
items = response["DistributionList"]["Items"]
for item in items:
cloud_front_domain_name = item["... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def host(self):\n if self.url.startswith(\"dns:\"):\n return self.url[4:]\n else:\n return urlparse(self.url).hostname",
"def get_domain():\n domain=\"\"\n for item in re.split(\"\\.\", env.host)[1:]:\n domain = domain + \".\" + item\n return domain.lstrip(\".\... | [
"0.7322436",
"0.71760046",
"0.7071095",
"0.7029442",
"0.7000298",
"0.69341964",
"0.6933069",
"0.6917955",
"0.6914039",
"0.6898984",
"0.6894848",
"0.6891883",
"0.6890801",
"0.6877511",
"0.681708",
"0.6752261",
"0.6731664",
"0.6730647",
"0.6730647",
"0.67285687",
"0.6695391",
... | 0.82743466 | 0 |
Lookup the Public DNS name for a ELB | def elb_public_lookup(session, hostname):
if session is None:
return None
client = session.client('elb')
responses = client.describe_load_balancers()
hostname_ = hostname.replace(".", "-")
for response in responses["LoadBalancerDescriptions"]:
if response["LoadBalancerName"].star... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rds_lookup(session, hostname):\n\n client = session.client('rds')\n response = client.describe_db_instances(DBInstanceIdentifier=hostname)\n\n item = response['DBInstances']\n if len(item) == 0:\n print(\"Could not find DNS for '{}'\".format(hostname))\n return None\n else:\n ... | [
"0.7090508",
"0.6931591",
"0.66295487",
"0.6527898",
"0.64692634",
"0.6408615",
"0.6370166",
"0.6294847",
"0.62296087",
"0.6155501",
"0.61130655",
"0.60973746",
"0.6082369",
"0.6069316",
"0.60271686",
"0.5922691",
"0.59071743",
"0.58485824",
"0.58454686",
"0.58105326",
"0.579... | 0.82099265 | 0 |
Look up ELB Id by name | def lb_lookup(session, lb_name):
if session is None:
return None
lb_name = lb_name.replace('.', '-')
client = session.client('elb')
response = client.describe_load_balancers()
for i in range(len(response['LoadBalancerDescriptions'])):
if (response['LoadBalancerDescriptions'][i]['L... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_elb ( elb_conn, elb_name ) :\n try :\n elb_r = elb_conn.get_all_load_balancers( load_balancer_names = [ elb_name ] )\n if len( elb_r ) > 0 :\n return elb_r[ 0 ]\n except :\n return None",
"def instanceid_lookup(session, hostname):\n if session is None:\n return None\... | [
"0.6410251",
"0.6320013",
"0.62699234",
"0.5826108",
"0.5814295",
"0.5814165",
"0.57875586",
"0.57076484",
"0.56870925",
"0.56859106",
"0.56775266",
"0.56501776",
"0.5644913",
"0.5644913",
"0.5629282",
"0.5629282",
"0.5629282",
"0.5623974",
"0.5578806",
"0.5548592",
"0.553271... | 0.55268645 | 21 |
Lookup up SNS topic ARN given a topic name | def sns_topic_lookup(session, topic_name):
if session is None:
return None
client = session.client('sns')
response = client.list_topics()
topics_list = response['Topics']
for topic in topics_list:
arn_topic_name = topic["TopicArn"].split(':').pop()
if arn_topic_name == topic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_topic_arn(topic_name):\n # https://stackoverflow.com/a/37723278/1558022\n sts_client = boto3.client('sts')\n account_id = sts_client.get_caller_identity().get('Account')\n\n return f'arn:aws:sns:eu-west-1:{account_id}:{topic_name}'",
"def get_full_topicarn ( base_topicarn, topicname ) :\n ... | [
"0.79431546",
"0.72963053",
"0.7135237",
"0.7135237",
"0.7130573",
"0.6910786",
"0.69055796",
"0.6537543",
"0.65364784",
"0.646367",
"0.6283038",
"0.59111613",
"0.5876922",
"0.5643607",
"0.56244606",
"0.55634636",
"0.5465788",
"0.54464096",
"0.54258615",
"0.5421659",
"0.53438... | 0.8113506 | 0 |
Delete all of the SQS Queues that start with the given domain name | def sqs_delete_all(session, domain):
client = session.client('sqs')
resp = client.list_queues(QueueNamePrefix=domain.replace('.','-'))
for url in resp.get('QueueUrls', []):
client.delete_queue(QueueUrl=url) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_test_queues(prefix=TEST_NAME_PREFIX, region_name=None):\n sqs = boto3.resource('sqs', region_name=region_name)\n num_queues = 0\n try:\n for queue in sqs.queues.all():\n if re.match(r'.+%s\\d+' % TEST_NAME_PREFIX, queue.url):\n queue.delete()\n num... | [
"0.7308705",
"0.6090805",
"0.60719943",
"0.5983654",
"0.59769964",
"0.59579396",
"0.5926879",
"0.5807085",
"0.57812786",
"0.57787776",
"0.57786417",
"0.57765925",
"0.57747895",
"0.5687993",
"0.5681951",
"0.56519437",
"0.5629436",
"0.5589249",
"0.5585626",
"0.55741715",
"0.556... | 0.83173805 | 0 |
Lookup up SQS url given a name. | def sqs_lookup_url(session, queue_name):
client = session.client('sqs')
resp = client.get_queue_url(QueueName=queue_name)
return resp['QueueUrl'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def play_name(self, name):\n self.name = name\n self._stream_from_name()\n return self.URL",
"def get_by_url(self, url, pool_name=None):\n\t\tif not pool_name:\n\t\t\treturn self.pool[url]\n\t\treturn getattr(self, pool_name)[url]",
"def image_url(self, name):\r\n s3_key = self._gen... | [
"0.570739",
"0.56668997",
"0.55974376",
"0.55352825",
"0.55016017",
"0.54813766",
"0.5397629",
"0.53500366",
"0.5313121",
"0.53008205",
"0.5254056",
"0.5221821",
"0.52081007",
"0.52081007",
"0.5193847",
"0.5184935",
"0.5153158",
"0.5135208",
"0.5130682",
"0.5095509",
"0.50650... | 0.75557625 | 0 |
Requests a certificate in the AWS Certificate Manager for the domain name | def request_cert(session, domain_name, validation_domain):
if session is None:
return None
client = session.client('acm')
validation_options = [
{
'DomainName': domain_name,
'ValidationDomain': validation_domain
},
]
response = client.request_certific... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request(domain):\n if not domain:\n logger.error(\n \"ctl:info:generate\", \"Choose a fully-qualified domain name of the \"\n \"certificate. Must match a domain present on the system\"\n )\n domain = click.prompt(\"Domain name\")\n try:\n client().certifi... | [
"0.71145135",
"0.68516237",
"0.68167555",
"0.6727174",
"0.63520133",
"0.62255585",
"0.6130389",
"0.61267835",
"0.5947188",
"0.5946464",
"0.587936",
"0.5868433",
"0.5864199",
"0.5861729",
"0.5860213",
"0.58348227",
"0.5812201",
"0.5778908",
"0.57471037",
"0.5649767",
"0.564291... | 0.7149025 | 0 |
Get hosted zone by looking up account name and using that to tell which zone to return. | def get_hosted_zone(session):
account = get_account_id_from_session(session)
if account == hosts.PROD_ACCOUNT:
return hosts.PROD_DOMAIN
elif account == hosts.DEV_ACCOUNT:
return hosts.DEV_DOMAIN
else:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_zone(cls, name):\n\n def get_closest(n):\n \"\"\"\n Return closest matching zone\n \"\"\"\n while n:\n try:\n return DNSZone.objects.get(name=n)\n except DNSZone.DoesNotExist:\n pass\n ... | [
"0.7249278",
"0.70573413",
"0.6600804",
"0.6556853",
"0.65454966",
"0.6509461",
"0.6491115",
"0.64886916",
"0.64364696",
"0.6349082",
"0.6179819",
"0.61753106",
"0.61310756",
"0.61241627",
"0.6072795",
"0.59662193",
"0.5963174",
"0.5910606",
"0.58478206",
"0.58478206",
"0.584... | 0.7208443 | 1 |
Look up Hosted Zone ID by DNS Name | def get_hosted_zone_id(session, hosted_zone):
if session is None:
return None
client = session.client('route53')
response = client.list_hosted_zones_by_name(
DNSName=hosted_zone,
MaxItems='1'
)
if len(response['HostedZones']) >= 1:
full_id = response['HostedZones'][0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_zone(self, conn, host):\n fl = 'name=\"%s\"' % host\n request = conn.instances().aggregatedList(project=PROJECT, filter=fl)\n \twhile request is not None:\n \t\tresponse = request.execute()\n \t\tzones = response.get('items', {})\n \t\tfor zone in zones.values():\n \t\t\tfor in... | [
"0.6939275",
"0.68444455",
"0.6659618",
"0.6528168",
"0.65258527",
"0.6513309",
"0.6497108",
"0.6493159",
"0.64013845",
"0.6360987",
"0.63570255",
"0.6320351",
"0.63168037",
"0.6304107",
"0.6270168",
"0.62638074",
"0.62486017",
"0.6175367",
"0.61118865",
"0.6106997",
"0.61064... | 0.60102695 | 28 |
Updates or Creates a domain name with FQDN resource. | def set_domain_to_dns_name(session, domain_name, dns_resource, hosted_zone):
if session is None:
return None
client = session.client('route53')
hosted_zone_id = get_hosted_zone_id(session, hosted_zone)
if hosted_zone_id is None:
print("Error: Unable to find Route 53 Hosted Zone, " + ho... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_dns(self):\n if self.ptr:\n which_zone = None\n zones = dns.models.Zone.objects.all()\n for zone in zones:\n if self.ptr.endswith(zone.name) or self.ptr.endswith(zone.name + '.'):\n which_zone = zone\n break\n\n... | [
"0.61005515",
"0.5949715",
"0.58637345",
"0.58026123",
"0.57765675",
"0.57385725",
"0.56413877",
"0.5568498",
"0.55607516",
"0.5557578",
"0.55217475",
"0.55150574",
"0.55067784",
"0.5486445",
"0.5471696",
"0.5465719",
"0.546032",
"0.5456307",
"0.54177785",
"0.5328181",
"0.532... | 0.62173575 | 0 |
gets to resource name attached to a domain name | def get_dns_resource_for_domain_name(session, domain_name, dns_resource, hosted_zone):
if session is None:
return None
client = session.client('route53')
hosted_zone_id = get_hosted_zone_id(session, hosted_zone)
if hosted_zone_id is None:
print("Error: Unable to find Route 53 Hosted Zo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def domain_name(self) -> str:\n return pulumi.get(self, \"domain_name\")",
"def domain_name(self) -> str:\n return pulumi.get(self, \"domain_name\")",
"def get_domain_name(self):\n return self.domain_name.get_text()",
"def domain_name(self) -> pulumi.Output[str]:\n return pulumi.g... | [
"0.7044255",
"0.7044255",
"0.6996854",
"0.68066776",
"0.68066776",
"0.68066776",
"0.677094",
"0.6686967",
"0.6686967",
"0.6686967",
"0.6535889",
"0.6506666",
"0.6484692",
"0.64764667",
"0.64130455",
"0.6407385",
"0.64038163",
"0.6345912",
"0.63330495",
"0.6319494",
"0.6309725... | 0.5892597 | 49 |
Delete all of the matching CNAME records from a DNS Zone | def route53_delete_records(session, hosted_zone, cname):
if session is None:
return None
client = session.client('route53')
hosted_zone_id = get_hosted_zone_id(session, hosted_zone)
if hosted_zone_id is None:
print("Could not locate Route53 Hosted Zone '{}'".format(hosted_zone))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_deletednsrecord(kasserver, kasapi):\n kasserver.delete_dns_record(\"test.example.com\", \"CNAME\")\n assert kasapi.requests_contains(\"delete_dns_settings\")",
"def delete_container_links(container):\n container_uri = container.cdn_uri.replace(\"http://\", \"\")\n domain = get_domain... | [
"0.68798274",
"0.6212371",
"0.6047711",
"0.60346884",
"0.5980792",
"0.58506405",
"0.5818954",
"0.57226974",
"0.5720566",
"0.57001406",
"0.56724554",
"0.56326467",
"0.56292945",
"0.56163657",
"0.5554157",
"0.554218",
"0.55259824",
"0.5514953",
"0.5445766",
"0.5426144",
"0.5409... | 0.70036846 | 0 |
Unsubscribe all subscriptions for the given SNS topic | def sns_unsubscribe_all(session, topic, region="us-east-1", account=None):
if session is None:
return None
if account is None:
account = get_account_id_from_session(session)
topic = "arn:aws:sns:{}:{}:{}".format(region, account, topic.replace(".", "-"))
client = session.client('sns')
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def unsubscribe(self, topic: str, subscription_id: int = None) -> None:\n ...",
"async def unsubscribe_topics(self) -> None:\n self._sub_state = await self._mqtt_client.unsubscribe(self._sub_state)",
"def unsubscribe(self, topic):\n request = protos.RequestUnsubscribe(topic=topic)\n ... | [
"0.78564173",
"0.7503416",
"0.7494931",
"0.7264927",
"0.7082679",
"0.6934921",
"0.6786763",
"0.6547516",
"0.6486138",
"0.6444043",
"0.64201444",
"0.6402963",
"0.63842636",
"0.63343644",
"0.6314208",
"0.63087684",
"0.62940603",
"0.6240863",
"0.6240863",
"0.62375754",
"0.623116... | 0.811901 | 0 |
Creates a new Topic | def sns_create_topic(session, topic):
if session is None:
return None
client = session.client("sns")
response = client.create_topic(Name=topic)
print(response)
if response is None:
return None
else:
return response['TopicArn'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_topic (self):\n return self.tm.create_topic()",
"def create_topic(project_id, topic_id):\n topic_path = PUBLISHER_CLIENT.topic_path(project_id, topic_id)\n topic = PUBLISHER_CLIENT.create_topic(request={\"name\": topic_path})\n print(\"Created topic: {}\".format(topic.name))",
"def c... | [
"0.8382125",
"0.8278133",
"0.78403986",
"0.7770088",
"0.7703768",
"0.7568904",
"0.74277943",
"0.74015033",
"0.7379665",
"0.7325611",
"0.7288096",
"0.7258471",
"0.7200558",
"0.7183344",
"0.7131199",
"0.7119998",
"0.70848787",
"0.7084135",
"0.68914306",
"0.674492",
"0.66853815"... | 0.7385752 | 8 |
Delete all of the IAM policies that start with the given domain name | def policy_delete_all(session, domain, path="/"):
client = session.client('iam')
resp = client.list_policies(Scope='Local', PathPrefix=path)
prefix = domain.replace('.', '-')
for policy in resp.get('Policies', []):
if policy['PolicyName'].startswith(prefix):
ARN = policy['Arn']
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def destroy_all(self):\n for name in self.app.config['SIMPLE_DOMAINS']:\n self.connection.delete_domain(name)",
"def delete_policies():\n if PoliciesOutput.POLICIES_EVENT not in ctx.instance.runtime_properties:\n return\n\n service_component_name = ctx.instance.runtime_... | [
"0.6473392",
"0.6243997",
"0.5969745",
"0.5849608",
"0.57430595",
"0.57022417",
"0.5679662",
"0.56782377",
"0.5672439",
"0.56152827",
"0.55565584",
"0.54859465",
"0.5423485",
"0.5404208",
"0.5362759",
"0.53223443",
"0.5299086",
"0.5266806",
"0.5250096",
"0.52498037",
"0.52363... | 0.71195954 | 0 |
Returns the arn associated the the role name. Using this method avoids hardcoding the aws account into the arn name. | def role_arn_lookup(session, role_name):
if session is None:
return None
client = session.client('iam')
response = client.get_role(RoleName=role_name)
if response is None:
return None
else:
return response['Role']['Arn'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def account_role_arn(self, role, partition='aws'):\n if not role or role.startswith(\"arn:aws\"):\n return role\n if not role.startswith(\"role/\"):\n role = \"role/\" + role\n return \"arn:{0}:iam::{1}:{2}\".format(partition, self.account_id, role)",
"def role_arn(self... | [
"0.7859572",
"0.7753478",
"0.7637809",
"0.7498932",
"0.7498932",
"0.7476314",
"0.7476314",
"0.7476314",
"0.7476314",
"0.74674606",
"0.74520385",
"0.74520385",
"0.74520385",
"0.74520385",
"0.74520385",
"0.73431563",
"0.73144424",
"0.73144424",
"0.73144424",
"0.71579766",
"0.71... | 0.7266079 | 19 |
Returns the arn associated the the role name. Using this method avoids hardcoding the aws account into the arn name. | def instance_profile_arn_lookup(session, instance_profile_name):
if session is None:
return None
client = session.client('iam')
response = client.get_instance_profile(InstanceProfileName=instance_profile_name)
if response is None:
return None
else:
return response['InstanceP... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def account_role_arn(self, role, partition='aws'):\n if not role or role.startswith(\"arn:aws\"):\n return role\n if not role.startswith(\"role/\"):\n role = \"role/\" + role\n return \"arn:{0}:iam::{1}:{2}\".format(partition, self.account_id, role)",
"def role_arn(self... | [
"0.7861198",
"0.7756153",
"0.76403385",
"0.7501626",
"0.7501626",
"0.747887",
"0.747887",
"0.747887",
"0.747887",
"0.747008",
"0.7452663",
"0.7452663",
"0.7452663",
"0.7452663",
"0.7452663",
"0.7345726",
"0.7315004",
"0.7315004",
"0.7315004",
"0.7266874",
"0.7158131",
"0.71... | 0.0 | -1 |
Test for existence of an S3 bucket. Note that this method can only test for the existence of buckets owned by the user. | def s3_bucket_exists(session, name):
client = session.client('s3')
resp = client.list_buckets()
for bucket in resp['Buckets']:
if bucket['Name'] == name:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def bucket_exists(self, bucket, s3_client=None):\n\n s3_client = s3_client or self.s3_client\n\n try:\n s3_client.list_objects(Bucket=bucket, MaxKeys=1)\n return True\n except botocore.exceptions.EndpointConnectionError:\n logging.error(\"Couldn't connect to an... | [
"0.8318233",
"0.8141941",
"0.8003047",
"0.789405",
"0.7766357",
"0.7745054",
"0.76827997",
"0.75209075",
"0.7424082",
"0.7327559",
"0.7192139",
"0.71852547",
"0.71528953",
"0.7121559",
"0.70840293",
"0.7035105",
"0.6945679",
"0.69106793",
"0.68924725",
"0.68634355",
"0.684299... | 0.8081882 | 2 |
gets the account id from the session using the iam client. This method will work even if you have assumed a role in another account. | def get_account_id_from_session(session):
if session is None:
return None
return session.client('iam').list_users(MaxItems=1)["Users"][0]["Arn"].split(':')[4] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def account_id():\n return client.get_caller_identity()['Account']",
"def id(self) -> str:\n account_id = self.__session.client(\"sts\").get_caller_identity().get(\"Account\")\n if account_id:\n return account_id\n raise ValueError(\"get_caller_identity did not return Account\"... | [
"0.716123",
"0.69258696",
"0.6868835",
"0.6868835",
"0.6868835",
"0.6868835",
"0.6868835",
"0.6868835",
"0.6868835",
"0.6868835",
"0.6804414",
"0.67929757",
"0.67919576",
"0.6678467",
"0.6673702",
"0.661376",
"0.6577138",
"0.6577138",
"0.6577138",
"0.6577138",
"0.6577138",
... | 0.797403 | 0 |
Returns the arn for a lambda given a lambda function name. | def lambda_arn_lookup(session, lambda_name):
if session is None:
return None
client = session.client("lambda")
response = client.get_function(FunctionName=lambda_name)
if response is None:
return None
else:
return response['Configuration']['FunctionArn'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_lambda_arn(region: str, first_part: str, second_part: str=None) -> str:\n client = boto3.client('lambda', region_name=region)\n response = client.list_functions()\n for x in response['Functions']:\n if second_part:\n if first_part in x['FunctionArn'] and second_part in x['Functio... | [
"0.62491465",
"0.6024986",
"0.59035015",
"0.5837769",
"0.5678364",
"0.56479216",
"0.55890566",
"0.54492086",
"0.5431791",
"0.5426185",
"0.53477263",
"0.52988434",
"0.52703404",
"0.5237456",
"0.5228843",
"0.5223322",
"0.52192754",
"0.52119076",
"0.5209872",
"0.52070284",
"0.51... | 0.7466593 | 0 |
Use SHA1 hash to hash a string, convert it to integer and shift right (160 m) places | def chord_hash(input_string):
h = hashlib.sha1() # 160 bit string
encoded_data = input_string.encode('utf-8')
h.update(encoded_data)
hex_string = h.hexdigest()
hex_value = int(hex_string, 16)
hash_integer_value = hex_value >> (160 - m)
return hash_integer_value | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sha1(self, s):\n\t\tself.sha1_calls += 1\n\t\treturn int(hashlib.sha1(s).hexdigest(), 16)",
"def computeHash(string):\n\tif isBytes(string):\n\t\tstring = string.decode(\"latin-1\")\n\thash_ = 63689\n\tfor char in string:\n\t\thash_ = hash_ * 378551 + ord(char)\n\treturn hash_ % 65536",
"def strhash(s: str... | [
"0.7196707",
"0.71366036",
"0.69533736",
"0.6906234",
"0.6869732",
"0.6842359",
"0.68278766",
"0.6794289",
"0.6765675",
"0.6747291",
"0.6716161",
"0.65964735",
"0.6587518",
"0.6550875",
"0.65399194",
"0.6535304",
"0.6471856",
"0.6450568",
"0.6412695",
"0.6410531",
"0.6410033"... | 0.7221014 | 0 |
Returns a value modulo 2^m. Used to wrap the value between 0 and 2^m. | def constrain(value):
size = 2**m
return (value%size) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def powermod(a, b, m):\n return mod(power(a, b), m)",
"def mod_pow(a: int, b: int, m: int) -> int:\n\tres = 1\n\twhile b > 0:\n\t\tif b % 2 != 0:\n\t\t\tres = (res * a) % m\n\t\ta = (a * a) % m\n\t\tb //= 2\n\treturn res",
"def powmod(x, k, m):\n ans = 1\n while k > 0:\n if odd(k):\n ... | [
"0.6996555",
"0.69771385",
"0.6762345",
"0.6758635",
"0.67553735",
"0.6721199",
"0.66469485",
"0.6575849",
"0.65531385",
"0.6530114",
"0.6495845",
"0.6472579",
"0.6451471",
"0.6407313",
"0.63954645",
"0.6324573",
"0.6313473",
"0.6308792",
"0.63087666",
"0.63069856",
"0.627844... | 0.61999327 | 25 |
Checks if a given value is in the range start to end while considering given options, i.e., including/excluding start and/or end of the range. | def is_between(value, start, end, including_start=False, including_end=False):
if not including_start and not including_end: # not include both start and end
if (start < value < end):
return True
elif (start > end) and (start < value <= (2**m - 1) or 0 <= value < end):
retu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def in_range(start, end, x):\n if start <= end:\n return start <= x <= end\n else:\n return start <= x or x <= end",
"def check_ranges(ranges, value):\n for fromto in ranges:\n start, end = fromto.split('-')\n if int(value) in range(int(start), int(end) + 1):\n return True\n ... | [
"0.747743",
"0.7280649",
"0.70743567",
"0.69564146",
"0.6774148",
"0.6771647",
"0.6761343",
"0.67048234",
"0.66715246",
"0.6633946",
"0.65986615",
"0.6595173",
"0.6571696",
"0.6535455",
"0.6530302",
"0.6497032",
"0.6490265",
"0.64786255",
"0.64565444",
"0.6445503",
"0.6378988... | 0.7582872 | 0 |
Pops up Advanced Options | def adv_new_window(self):
adv=workflow.advancedoptions_w.ADialog()
adv.exec_() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def option_show_advanced_dialog(self):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/optionShowAdvancedDialog/')))",
"def help_opt(self):\n print(OPTIONS)",
"def set_option_show_advanced_dialog(self, boolean, apikey=''):\n return six.next(six.itervalues(se... | [
"0.73913246",
"0.6876063",
"0.6805797",
"0.67696077",
"0.66258967",
"0.65356195",
"0.63632023",
"0.63622886",
"0.6299096",
"0.62647694",
"0.62544674",
"0.6179508",
"0.61681664",
"0.61645436",
"0.6160933",
"0.6142374",
"0.6141672",
"0.6141665",
"0.6137324",
"0.6122997",
"0.611... | 0.6164144 | 14 |
write undulator parameters into .pkl for storage | def und_pickle(self):
und=json.load(open("pickle\\und.json","r"))
und["energy"]=self.ui.und_energy.text()
und["current"]=self.ui.und_current.text()
und["period"]=self.ui.und_period.text()
und["num"]=self.ui.und_nperiods.text()
und["sigx"]=self.ui.und_sigx.text()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_pkl(self, filename):\n param_dict = {}\n param_dict['learningrate'] = self.learningrate\n param_dict['verbose'] = self.verbose\n param_dict['loadsize'] = self.loadsize\n param_dict['batchsize'] = self.batchsize\n param_dict['momentum'] = self.momentum\n par... | [
"0.64397955",
"0.6262204",
"0.6123736",
"0.59713453",
"0.5930658",
"0.58989054",
"0.58577263",
"0.58267593",
"0.57620645",
"0.57597244",
"0.57279533",
"0.5693982",
"0.5675025",
"0.56738997",
"0.5597991",
"0.5597991",
"0.5558043",
"0.5554464",
"0.5553245",
"0.5546644",
"0.5511... | 0.0 | -1 |
Loads default values from file, need to implement recalling numbers from saved run | def und_default(self):
f=open("pickle\\undload.json","r")
und=json.load(f)
f.close()
self.ui.und_energy.setText(und["energy"])
self.ui.und_current.setText(und["current"])
self.ui.und_kx.setText(und["kx"])
self.ui.und_ky.setText(und["ky"])
self.ui.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadDefaults(self):\n # (025) Merged into settings.RawSettings.\n pass",
"def init_from_file(self):\n self.src.load('start.00') \n self.oe1.load('start.01')\n #self.det.load('start.02')\n print('NOTE: variables loaded from start.00/start.01 files')",
"def load(se... | [
"0.6519448",
"0.6475309",
"0.61636525",
"0.6163593",
"0.61309457",
"0.60647124",
"0.60643244",
"0.6055603",
"0.6055603",
"0.6055603",
"0.5975182",
"0.595574",
"0.5928173",
"0.5853351",
"0.5782269",
"0.5742056",
"0.57281154",
"0.57196534",
"0.5714985",
"0.56829745",
"0.5681391... | 0.0 | -1 |
Loads default values from file, need to implement recalling numbers from last run | def und_load_values(self):
f=open("pickle\\und.json","r")
und=json.load(f)
f.close()
self.ui.und_energy.setText(und["energy"])
self.ui.und_current.setText(und["current"])
self.ui.und_kx.setText(und["kx"])
self.ui.und_ky.setText(und["ky"])
self.ui.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadDefaults(self):\n # (025) Merged into settings.RawSettings.\n pass",
"def init_from_file(self):\n self.src.load('start.00') \n self.oe1.load('start.01')\n #self.det.load('start.02')\n print('NOTE: variables loaded from start.00/start.01 files')",
"def write_d... | [
"0.65797085",
"0.63128245",
"0.6236716",
"0.6220871",
"0.6120827",
"0.6109339",
"0.610519",
"0.6086135",
"0.6086135",
"0.6086135",
"0.5866077",
"0.57987785",
"0.5787708",
"0.57814926",
"0.57568806",
"0.57412106",
"0.5712932",
"0.5709793",
"0.57072526",
"0.5689901",
"0.5677772... | 0.0 | -1 |
Runs undulator without heatbump | def main():
app=QtGui.QApplication(sys.argv)
ud=UDialog()
ud.exec_()
sys.exit(app.exec_()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def switch_to_untuned_inputs(self):\n\n self.h_e=self.inputs.noise_flat.T\n self.h=np.vstack([self.h_e,self.h_i])",
"def _DeRedden(lam,flux,ra,dec,dustmap_path='/Users/vzm83/Softwares/sfddata-master'): \n m = sfdmap.SFDMap(dustmap_path) \n flux_unred = pyasl.unred(lam,flux,m.ebv(ra,d... | [
"0.5825724",
"0.55327785",
"0.5512841",
"0.5493843",
"0.5459791",
"0.5459475",
"0.54442096",
"0.5436492",
"0.5357355",
"0.5350859",
"0.53506887",
"0.5313294",
"0.52936095",
"0.52837026",
"0.52817035",
"0.5275026",
"0.52726203",
"0.5268448",
"0.5245947",
"0.52385837",
"0.52303... | 0.0 | -1 |
remove a connection from the node | def remove_connection(self, conn: Connection):
self.__connections.remove(conn)
# now from other:
other = conn.other
for others_conn in other.get_connections():
if others_conn.other.node_id == self.node_id:
other.__connections.remove(others_conn)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_node():\n\ttry:\n\t\tnetwork.remove_connection()\n\texcept ValueError as err:\n\t\tfeedback.config(text=err)",
"def remove(self, node):\r\n\r\n # Allow node name, get the real node object\r\n if isinstance(node, basestring):\r\n name = node\r\n node = self.nodes[nam... | [
"0.8202315",
"0.7998739",
"0.7811269",
"0.7807282",
"0.77307093",
"0.76354533",
"0.73361313",
"0.72516835",
"0.72249186",
"0.72085327",
"0.7105888",
"0.7099663",
"0.7082802",
"0.70826495",
"0.70426273",
"0.7015274",
"0.70009166",
"0.6988864",
"0.6969774",
"0.6945303",
"0.6941... | 0.767631 | 5 |
remove a connection from a node, by the id of the other node in the connection | def remove_connection_by_id(self, node_id: int):
for conn in self.get_connections():
if conn.other.node_id == node_id:
self.remove_connection(conn)
break | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_connection(self, conn: Connection):\n self.__connections.remove(conn)\n # now from other:\n other = conn.other\n for others_conn in other.get_connections():\n if others_conn.other.node_id == self.node_id:\n other.__connections.remove(others_conn)\n ... | [
"0.75725925",
"0.7457941",
"0.7354663",
"0.7288606",
"0.72552603",
"0.70799124",
"0.70066655",
"0.6946529",
"0.69460434",
"0.6903269",
"0.68844795",
"0.68477476",
"0.6784337",
"0.6707545",
"0.668367",
"0.66627955",
"0.6633565",
"0.65117043",
"0.649248",
"0.64896923",
"0.64595... | 0.8295772 | 0 |
remove all connection but the input one | def keep_only_connection(self, conn_to_keep: Connection, apply_for_other=False):
for conn_other_id in self.get_connections_ids().copy():
if conn_other_id != conn_to_keep.other.node_id:
self.remove_connection_by_id(conn_other_id)
if not apply_for_other:
return
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_connection(self, source, target):\r\n\r\n connection = (self.coalesce_node(source), self.coalesce_node(target))\r\n self.connections.discard(connection)",
"def removeConnection(tagA, tagB): #@NoSelf",
"def remove_connection(self, conn: Connection):\n self.__connections.remove(c... | [
"0.7204449",
"0.709915",
"0.7043632",
"0.6896871",
"0.68019485",
"0.6683061",
"0.6558739",
"0.6539934",
"0.65027815",
"0.6491711",
"0.6482698",
"0.64230627",
"0.64163333",
"0.6373198",
"0.6361596",
"0.63564336",
"0.6348523",
"0.6335339",
"0.6326395",
"0.6289121",
"0.6273604",... | 0.6474718 | 11 |
check if all inputs are torch.Tensor | def check_input_type(func):
@functools.wraps(func)
def wrapper_check_input_type(*args):
new_args = []
for X in list(args):
new_args.append(_check_type(X))
return func(*new_args)
return wrapper_check_input_type | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_is_tensor(obj):\n if not isinstance(obj, torch.Tensor):\n raise TypeError(\"Input type is not a torch.Tensor. Got {}\".format(type(obj)))",
"def _is_tensor(x: Any) -> bool:\n if has_tensorflow and isinstance(x, _TfTensor):\n return True\n if has_pytorch and isinstance... | [
"0.763875",
"0.7580402",
"0.74269634",
"0.7156365",
"0.70370084",
"0.6998518",
"0.6929256",
"0.687199",
"0.68316144",
"0.67247117",
"0.6717951",
"0.6665843",
"0.66343147",
"0.65878856",
"0.65676725",
"0.6534087",
"0.6494567",
"0.6458143",
"0.6451148",
"0.63843507",
"0.636687"... | 0.0 | -1 |
check if all inputs are torch.Tensor | def check_object_input_type(func):
@functools.wraps(func)
def wrapper_check_input_type(ref, *args):
new_args = [ref]
for X in list(args):
new_args.append(_check_type(X))
return func(*new_args)
return wrapper_check_input_type | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_is_tensor(obj):\n if not isinstance(obj, torch.Tensor):\n raise TypeError(\"Input type is not a torch.Tensor. Got {}\".format(type(obj)))",
"def _is_tensor(x: Any) -> bool:\n if has_tensorflow and isinstance(x, _TfTensor):\n return True\n if has_pytorch and isinstance... | [
"0.763875",
"0.7580402",
"0.74269634",
"0.7156365",
"0.70370084",
"0.6998518",
"0.6929256",
"0.687199",
"0.68316144",
"0.67247117",
"0.6717951",
"0.6665843",
"0.66343147",
"0.65878856",
"0.65676725",
"0.6534087",
"0.6494567",
"0.6458143",
"0.6451148",
"0.63843507",
"0.636687"... | 0.0 | -1 |
Generate key using random bytes with specified size. | def generate_key(self, size):
key = bytearray()
for i in range(0,size):
random_byte = ord(os.urandom(1))
key.append(random_byte)
return key | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_key():\n return get_random_bytes(KEY_SIZE)",
"def random_key(size):\n return ''.join(random.choice(string.letters) for _ in range(size))",
"def get_random_secret_key(cls, size=None):\n if not size:\n size = cls.default_secret_key_size\n return os.urandom(size)",
"d... | [
"0.86057556",
"0.80857086",
"0.8032245",
"0.8031311",
"0.8002937",
"0.79636395",
"0.7943351",
"0.790454",
"0.7867546",
"0.7851878",
"0.77818877",
"0.7591018",
"0.7578894",
"0.75569624",
"0.7556202",
"0.74411345",
"0.74128795",
"0.73925257",
"0.7379331",
"0.72996837",
"0.72394... | 0.8874437 | 0 |
'Encrypt' the password with the key. Reverse key bytes and XOR with password bytes. Very low security but a bit obfuscated. | def mix_keys(self, password, key):
rev_key = list(reversed(key)) # Reverse bytes
result = bytearray()
for i in range(0, len(password)):
xored = password[i] ^ rev_key[i] # Mix each byte
result.append(xored)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def xor_encode(data, key):\n if not data:\n return \"\"\n if not key:\n raise exceptions.EncryptError\n return binascii.hexlify(\n ''.join(chr(ord(a) ^ ord(b)) for a, b in zip(data, key)).encode(\"utf-8\")).decode(\"utf-8\")",
"def encrypt_password(pass_to_encrypt):\n\n temp_key ... | [
"0.71066976",
"0.70337445",
"0.70089537",
"0.6976745",
"0.69720566",
"0.68509895",
"0.6773852",
"0.6713531",
"0.669853",
"0.6677601",
"0.66625684",
"0.6630633",
"0.66287386",
"0.6601027",
"0.6546598",
"0.65335375",
"0.6481441",
"0.64804226",
"0.646954",
"0.6465444",
"0.643424... | 0.70879525 | 1 |
Log of the loss (error) summed over all entries The negative of the logarithm of the frequency (probability) of the predicted label given the true binary label for a category. | def log_loss(actual, predicted):
predicted, actual = np.array(predicted), np.array(actual)
small_value = 1e-15
predicted[predicted < small_value] = small_value
predicted[predicted > 1 - small_value] = 1. - small_value
return (-1. / len(actual)) * np.sum(
actual * np.log(predicted) + (1. - ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_loss(self):\n probabilities = self.probability_array().copy()\n # need to flip the probabilities for p < 0.5 with this binary case.\n # 1 - old_val is same as oldval*-1 + 1. Do in 2 steps:\n probabilities[np.equal(0, self.y)] *= -1\n probabilities[np.equal(0, self.y)] +=... | [
"0.732824",
"0.71484697",
"0.70312464",
"0.7027971",
"0.7025981",
"0.69825447",
"0.696504",
"0.69374216",
"0.69364244",
"0.6865856",
"0.68495315",
"0.68495315",
"0.6829255",
"0.6797045",
"0.67773986",
"0.6731861",
"0.66845536",
"0.66764647",
"0.6645182",
"0.6607527",
"0.65839... | 0.65407634 | 24 |
Finds the peak in the specified time range. Finds the peak in the data in the specified time range. You must pass it pretrigger and timebase as well as the time and data series. timebase is an integer equal to (1 us)/(delta t of the digitizer). For example, if capturing data at 10 MHz, timebase = (1e6/1e7) = 10. For da... | def polyPeak_noPlot(time, data, timerange = [40,80],axis = 'x'):
# Find the indices corresponding to the ends of the time range
t1 = mj.tindex(time,timerange[0])#+pretrigger)
t2 = mj.tindex(time,timerange[1])#+pretrigger)
# print 't1=', t1
# print 't2=', t2
# generate an array of indices spanni... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def peak(data, fft_data=None):\n return np.max(np.abs(data))",
"def find_peak(mhw, mhw_relSeas, ev, tt_start):\n tt_peak = np.argmax(mhw_relSeas)\n mhw[\"time_peak\"].append(mhw[\"time_start\"][ev] + tt_peak)\n mhw[\"date_peak\"].append(date.fromordinal(mhw[\"time_start\"][ev] + tt_peak))\n mhw[\"... | [
"0.6256507",
"0.62215835",
"0.61286575",
"0.59447867",
"0.5906512",
"0.5898816",
"0.58075976",
"0.5780191",
"0.57295424",
"0.5648836",
"0.5639455",
"0.5607322",
"0.5568726",
"0.55157095",
"0.551521",
"0.5498673",
"0.54892355",
"0.54749453",
"0.5392688",
"0.53639615",
"0.53472... | 0.6415059 | 0 |
Compute B field of Helmholtz coil at (x,y,z) i is current in amps and coil is the coil selection. 1 for the old wooden coil 2 for the new delrin coil Please, please enter the radial position in METERS. | def helmholtz2(r, i = 1.0, coil = 2):
r1, r2, r3 = r
# a is the radius of the coil in meters, and d is the distance between the
# two coils.
if coil == 1:
# coil 1 is the old wooden coil. It has two turns per side, a radius
# of 6.1" and a separation of 5.9".
a = 6.1 * 0.0254
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_magnetic_field(self, coords, params={}, basis=\"rpz\"):",
"def getMagneticField(self, z):\n return float(self.solenoid.B_interp(z))",
"def compute_magnetic_field(self, coords, params=None, basis=\"rpz\"):\n assert basis.lower() in [\"rpz\", \"xyz\"]\n if isinstance(coords, Grid... | [
"0.599397",
"0.5703977",
"0.554072",
"0.5501309",
"0.5486127",
"0.54798865",
"0.54760885",
"0.54760885",
"0.5459302",
"0.5427586",
"0.53788805",
"0.53339124",
"0.53275996",
"0.53201574",
"0.52815235",
"0.5273773",
"0.5241065",
"0.5233045",
"0.5220011",
"0.5209557",
"0.5185021... | 0.5485373 | 5 |
Provides positions in meters along probe stalks for 4x4 array of probes built by M. Kaur. | def get_probeLocs_calib_setup(dir, num_probes = 16):
position_vectors = [[0] * 3 for i in range(num_probes)]
#every x postion
# Convert to meters
x_pos = [-4.25*1e-3*25.4, -4.25*1e-3*25.4, 4.24*1e-3*25.4, 4.24*1e-3*25.4]
y_pos = [-4.25*1e-3*25.4, 4.24*1e-3*25.4, 4.24*1e-3*25.4, -4.25*1e-3*25.4]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_probeLocs_calib_setup_cm(dir, num_probes = 16):\n position_vectors = [[0] * 3 for i in range(num_probes)]\n\n #every x postion\n\n # Convert to meters\n x_pos = [-4.25*2.54, -4.25*2.54, 4.24*2.54, 4.24*2.54]\n y_pos = [-4.25*2.54, 4.24*2.54, 4.24*2.54, -4.25*2.54]\n z_pos = [-2.25*2.54, -... | [
"0.68602735",
"0.635877",
"0.622993",
"0.62070554",
"0.57699996",
"0.5661007",
"0.5541144",
"0.54987085",
"0.54753906",
"0.54418695",
"0.5396649",
"0.5383856",
"0.53815603",
"0.5378696",
"0.53735656",
"0.534419",
"0.53433716",
"0.5325735",
"0.53203666",
"0.52891964",
"0.52763... | 0.68148327 | 1 |
Provides positions in meters along probe stalks for 4x4 array of probes built by M. Kaur. | def get_probeLocs_calib_setup_cm(dir, num_probes = 16):
position_vectors = [[0] * 3 for i in range(num_probes)]
#every x postion
# Convert to meters
x_pos = [-4.25*2.54, -4.25*2.54, 4.24*2.54, 4.24*2.54]
y_pos = [-4.25*2.54, 4.24*2.54, 4.24*2.54, -4.25*2.54]
z_pos = [-2.25*2.54, -0.75*2.54, 0.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_probeLocs_calib_setup(dir, num_probes = 16):\n position_vectors = [[0] * 3 for i in range(num_probes)]\n\n #every x postion\n\n # Convert to meters\n x_pos = [-4.25*1e-3*25.4, -4.25*1e-3*25.4, 4.24*1e-3*25.4, 4.24*1e-3*25.4]\n y_pos = [-4.25*1e-3*25.4, 4.24*1e-3*25.4, 4.24*1e-3*25.4, -4.25*1... | [
"0.6814141",
"0.6357938",
"0.6228107",
"0.62063867",
"0.576915",
"0.56598634",
"0.5540284",
"0.5499135",
"0.5474505",
"0.54411244",
"0.5393473",
"0.5382529",
"0.5381584",
"0.53801537",
"0.5371877",
"0.53437704",
"0.53433514",
"0.5324205",
"0.5318798",
"0.5288676",
"0.5275662"... | 0.68606234 | 0 |
Written by M. Kaur KG 20190605 This (I think) goes though every shot, and finds the maximum magetic field then averages the maximum signal over several shots | def getRatio(probe_num, position_vector, shot_range, dir, day ='050119r'):
ratio_x = 0
ratio_y = 0
ratio_z = 0
# helm_B = [0,0,0]
divideby = 0
for shot in range(shot_range[0], shot_range[1]+1):
print( 'On shot ', day+str(shot), ' for probe ',probe_num)
x,y,z, currmax,helmB_new =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coldaverage( names):\n\n rs = radioastronomy.Spectrum() # create input and average structures\n avenames = names # create an output list to average\n\n# assume only a limited range of galactic latitudes are available\n# not range above +/-60.\n use60Range = False\n minGlat = 90. ... | [
"0.62299377",
"0.6013409",
"0.5896017",
"0.58733714",
"0.58249664",
"0.5776324",
"0.57661194",
"0.56742597",
"0.56561136",
"0.5610272",
"0.5569868",
"0.55585563",
"0.55527085",
"0.55359155",
"0.54949343",
"0.5475598",
"0.5468535",
"0.54521996",
"0.54429483",
"0.5442529",
"0.5... | 0.0 | -1 |
This finds the ratio between the idealized helmholtz field and the actual recoreded signal This also corrects for inverted signals... however due to what I'm assuming is noise, finding the inverted ones are a bit tricky feel free to uncomment the plotting lines and see if it needs adjusments, though I did get it workin... | def ratio_4_doc(shot, dir, num_probes = 16):
# data = [[0] *3 for i in range(num_probes)]
# magdata = hdr.getMagData(shot)
probe_locs = get_probeLocs_calib_setup(shot)
data=hdr.getquikData(shot)
time,eastcurrent,westcurrent = loadcurrent(shot)#using eastcurrent
ratios = [[0]*3 for i in range(num... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _calculate_measurement_error(self): \n \n # Calculate Hartmann Spot\n # FIXME what are factor_1, factor_2 ???\n factor_1, factor_2 = 206265*5.89e-7, 206265*6.5e-7\n term1, term2 = factor_1/self.actuator_spacing, factor_2/self.r0\n hartmann_spot = np.max([term1, term... | [
"0.62044317",
"0.59503055",
"0.5934977",
"0.58116406",
"0.5744772",
"0.5688612",
"0.5682206",
"0.5657256",
"0.5637151",
"0.56292534",
"0.562283",
"0.56201357",
"0.5602905",
"0.5597058",
"0.55753255",
"0.55715555",
"0.55521727",
"0.5543683",
"0.55348676",
"0.5511092",
"0.55000... | 0.6009351 | 1 |
This function is where any userspecified values shoulbe be. Given shots in the x, y and z direction, it finds position vectors (a 16 by 3 array becuase there are 16 probe locations (4 locations on 4 probes) and each probe location has an x, y, and z coordinate relative to the center of the Bfield) then uses those posit... | def generateMatrix():
num_probes = 16
# print(position_vectors)
# Create the (48x4) calibration matrix:
calibration_lookup= [[0] * 3 for i in range(num_probes)]
calibration_matrix = [[0] * 9 for i in range(num_probes)]
counter = 0
# first populate with x-direction:
shot_range = [17, 20... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_magnetic_field(self, coords, params={}, basis=\"rpz\"):",
"def get_probeLocs_calib_setup_cm(dir, num_probes = 16):\n position_vectors = [[0] * 3 for i in range(num_probes)]\n\n #every x postion\n\n # Convert to meters\n x_pos = [-4.25*2.54, -4.25*2.54, 4.24*2.54, 4.24*2.54]\n y_pos = [... | [
"0.63979864",
"0.58925015",
"0.5888225",
"0.5737547",
"0.56940204",
"0.566803",
"0.5652638",
"0.561245",
"0.56079805",
"0.5605385",
"0.56043845",
"0.5591721",
"0.5587432",
"0.55768406",
"0.55294365",
"0.5511706",
"0.55075437",
"0.54954225",
"0.5465866",
"0.54398566",
"0.54375... | 0.51907223 | 42 |
More precise than plotting becuase it doens't have to thin the times For every shot, find the calibration value, then average it | def generatelookup(num_probes = 16):
calibration_lookup= [[0] * 3 for i in range(num_probes)]
# print(calibration_lookup)
day = '050119r'
date = '050119'
def _run_calib(shots, dir):
""" Helper function """
for shot in shots:
shot = day+str(shot)
ratios = rati... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def photometric_calibration():\n pass",
"def calibration(self) -> int:",
"def doRun(run=77):\n r = xanes_analyzeRun.AnalyzeRun(run)\n r.load()\n calibs = list(r.results.keys())\n calibs.sort()\n p2 = [np.nanmedian(r.results[c].p1, axis=0) for c in calibs]\n p2 = np.asarray(p2)\n ref... | [
"0.63869935",
"0.6185194",
"0.6163579",
"0.60991865",
"0.5894125",
"0.5810871",
"0.57928896",
"0.5788251",
"0.5757029",
"0.5747513",
"0.5740013",
"0.567313",
"0.56440735",
"0.56413454",
"0.56288755",
"0.5609218",
"0.56066924",
"0.5535295",
"0.550225",
"0.5496323",
"0.5492045"... | 0.51465684 | 84 |
Retrieve the .mat filenames for the troika dataset. Review the README in ./datasets/troika/ to understand the organization of the .mat files. | def LoadTroikaDataset():
data_dir = "./datasets/troika/training_data"
data_fls = sorted(glob.glob(data_dir + "/DATA_*.mat"))
ref_fls = sorted(glob.glob(data_dir + "/REF_*.mat"))
return data_fls, ref_fls | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def matrices_names(self, folder=None):\n if folder is None:\n abs_path = os.path.abspath(os.path.dirname(sys.argv[0]))\n folder = os.path.join(abs_path, 'matrix')\n\n matrix_name_x = \"%s_%s_%s_%s_x.txt\" % (\n self.D, self.Rs, self.axe_X, self.FOV_img)\n matri... | [
"0.62999743",
"0.5992772",
"0.5919344",
"0.58812904",
"0.5764292",
"0.57600445",
"0.5720086",
"0.56433666",
"0.5607395",
"0.5561246",
"0.55274653",
"0.55114895",
"0.5472151",
"0.54595053",
"0.54580384",
"0.5449727",
"0.54414546",
"0.54392225",
"0.54072315",
"0.5384773",
"0.53... | 0.73199314 | 0 |
Loads and extracts signals from a troika data file. | def LoadTroikaDataFile(data_fl):
data = sp.io.loadmat(data_fl)['sig']
return data[2:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_signal_raw(filepath):\n signal_raw = sio.loadmat(filepath)['signal_raw']\n return signal_raw",
"def _load_unlabeled(self, path):\n signal, info = wfdb.rdsamp(path)\n self.fs = 250\n self.lead_match = ['anonymous1', 'anonymous2']\n self.raw_data = np.transpose(np.array([... | [
"0.626287",
"0.62021583",
"0.6054611",
"0.5924737",
"0.5851997",
"0.5830161",
"0.5783297",
"0.573766",
"0.5731504",
"0.57031226",
"0.5665131",
"0.56484056",
"0.5623416",
"0.56071955",
"0.5598461",
"0.5585858",
"0.55778784",
"0.55460054",
"0.5543505",
"0.553586",
"0.5512837",
... | 0.6063819 | 2 |
Loads and extracts reference from a troika reference file. | def LoadTroikaRefFile(ref_fl):
refdata = sp.io.loadmat(ref_fl)['BPM0']
return refdata[2:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_reference(self, path_to_reference):\n with open(path_to_reference,'r') as f:\n qids_to_relevant_docids = self.load_reference_from_stream(f)\n return qids_to_relevant_docids",
"def test_load_ref():\n\n itraj = os.path.join(path, \"alanine_dipeptide.nc\")\n iref = os.path.jo... | [
"0.65891796",
"0.63777584",
"0.6298703",
"0.6292496",
"0.6262168",
"0.60937804",
"0.605416",
"0.5891338",
"0.5869947",
"0.58570164",
"0.5797035",
"0.5793951",
"0.57778513",
"0.57709974",
"0.57157594",
"0.56981564",
"0.56818175",
"0.56198025",
"0.56030697",
"0.5597448",
"0.558... | 0.6084144 | 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.